Download ppt

yes no Was this document useful for you?
   Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Document related concepts

Fault tolerance wikipedia, lookup

Corecursion wikipedia, lookup

Social computing wikipedia, lookup

Agent-based model wikipedia, lookup

Theoretical computer science wikipedia, lookup

Lateral computing wikipedia, lookup

Natural computing wikipedia, lookup

Trusted Computing wikipedia, lookup

The article collection
Fredrik Kilander
• “On agent-based software engineering” Nick
Jennings, 1999
• “An agent-based approach for building complex
software systems” Nick Jennings 2001
• “A note on distributed computing” Waldo, Wyant,
Wollrath, Kendall, 1994
• “The seven deadly sins of distributed systems”
Steve Muir, 2004
On agent-based software engineering
1. introduction
2. essential concepts of agent-based computing
the appeals of the agent-based approach
why agent-based techniques will succeed
the drawbacks
modelling on the social level
the wider implications for AI and CS
In traditional systems development...
• interactions between components are too
rigidly defined
• organisational structure is not captured well
Agents, on the other hand...
• are well defined (they have boundaries and
• are embedded in an environment
• are designed to fulfill a purpose
• are autonomous (need no external activation)
• are reactive and proactive
• are already organised in hierarchies
Agents are also...
• flexible in their interactions
• adaptable to changes in the environment
• able to work in teams for a common goal
Jennings argues that... (1/3)
• ”agent-oriented decomposition is an
effective way of partitioning the problem
Decomposition → distribution and decentralization
Decentralization → less control complexity
Jennings argues that... (2/3)
• ”the key abstractions of the agent-oriented
mindset are a natural means of modeling
complex systems”
Subsystems → agent hierarchies
Subsystem components → social interactions
Jennings argues that... (3/3)
• ”the agent-oriented philosophy for dealing
with organisational relationships is
appropriate for complex systems”
Agent-based systems flexibly form and reshape
Individual agents or groups can be developed
separately and incrementally added to the system
• interaction patterns are unpredictable
• emergent system behaviour is unpredictable
= (*) =
A note on distributed computing
Waldo et al
• Distributed computing is different from
local computing
• The programmer should be aware of this
• The language should not hide it
A (false) vision of unified
• Object-oriented design conquers all
• Remote objects appear to be local
• Failures depend on the implementation, not
on design
Hard problems in distributed computing
Memory access (no pointers => copy)
Partial failure
Interfaces and design
• Design remote interfaces to expect
• Accept that the programmer must be
informed about breakdowns
• E.g. java.rmi.RemoteException
= (*) =
The seven deadly sins
of distributed systems
• Experiences of real systems (PlanetLab
Node Manager)
• 400+ Internet nodes at 175 locations.
1 Networks are unreliable
• Large heterogenous networks are
fundamentally unreliable
• Packet loss
• Packet duplication
• Packet reordering
• Highly variable latency
2 DNS names make poor node
Human errors
Network reorganisation
Infrastructure failures
Network asymmetry (e.g. NAT)
Non-static addresses, multihoming
3 Local clocks are unreliable
System timing is poor
High load
NTP not always available
NTP: Network Time Protocol
4 Inconsistent node configuration
is the norm
Version skew
Inaccessible nodes
Update times
No global synchronization
5 Improbable events are frequent
Lots of nodes
Rare bugs WILL manifest themselves
Application programmers must not cut
corners! (“Oh, this error will never happen…”)
6 Over-utilization is the norm
• All systems are used
• No idle time
• Resource expiration times must be extended
7 Limited system transparency
hampers debugging
• Incomplete access to remote nodes
• Virtualization hides details
Conclusions for distributed
Local assumptions fail
Applications must cover all failure modes
Resource management is harder
Local operations are affected too