Slashdot Mirror
Review:Developing Intelligent Agents for Distributed Systems
What's Bad? The main problem that I had with this book was that it tried to take on too much. While trying to cover every aspect involved in developing agents, it ends up covering none of them very well. Instead of detailed coverage of any subject, we get a brief introduction to a wide spread of subjects and pointers for further information.
Another thing that I found annoying is the authors' exuberance for Smalltalk and Java and their downplaying the power of C++. They seem to be under the impression that C++ is dead and obsolete. They also completely fail to mention Perl. This is curious considering the power of Perl for these sorts of applications. I suppose they don't like it because they are trying to develop a pure object oriented system but it is by far the easiest way to rip apart HTML documents. While Java may be the language of the future, I think C++ with maybe some Perl tools provides the best platform for agent development today.
What's Good? The huge range of topics covered in this book is both a strength and a weakness. If you want to get a very general overview of many of these areas, it would be much cheaper to buy and read this book than a dozen books covering them in detail. This book would probably be good to give a manager or non-programmer when trying to explain what an agent is and what technologies are used to develop them.
In addition, the discussion of agent architectures is somewhat interesting and useful. I haven't seen many books cover this stuff very well. Several different organizational possibilities are presented with advantages and disadvantages. I found some of this to be rather shallow and commonsensical but I suppose it would be useful to someone with no knowledge of agents.
So What's In It For Me? If you are looking for a good overview of a wide range of fields involved in the development of intelligent agents, this book may be for you. It introduces artificial intelligence, fuzzy logic, object orientation, distributed computing, agent architecture, and several programming languages. Unfortunately, to actually start writing agents, you will need to read separate books on most of these topics. It does give you a starting place and some ideas about the approaches that others are trying. If you are an experienced programmer looking to start into agents, you will need to skip over large sections (like the introduction to object oriented programming) to keep from being bored. The sections on agent architecture are the best and are probably worth reading if you are trying to get into the field. Overall though, I found this book fairly disappointing. In the authors' defense, this is a large subject that would be difficult to cover with the wide scope that they are attempting. I think it is better left to books specializing on more manageable sub-areas.
Purchase this book over at Computer Literacy, and help Slashdot out.
Table of Contents- Introduction
- From Artificial Intelligence Comes Intelligent Agents
- Converging Technologies that Facilitate and Enable Agents
- Agent-Enabling Infrastructures
- Agent Architectures
- Agent Design Considerations
- Developing Intelligent Agents Now
- Agent Applications
- Agent Futures
C++ is unbeatable where the criteria are upward compatibility from C and imposing absolutely zero cost for unused features.
Java shines at exporting executables across heterogeneous networks.
Perl raises the complexity of what may be reasonably done with ad hoc, quick and dirty solutions. And although I haven't used them, it's OO capabilities look like good steps in the right direction.
The same is true of other languages. Each can be useful. Each can be misused. Attacks and flaming don't accomplish much besides temporary emotional gratification to the writer.
All that said, I recommend taking a look at Eiffel. Compared to all other languages I know, Eiffel is the only commercial language that gets static typing exactly right, implements multiple inheritance powerfully and flexibly, provides generic and constrained generic classes without multiple copies of code, supports design by contract in the language itself, and has a coherent OO approch to exception handling. Here are some links:
SmallEiffel The GNU Eiffel Compiler compiles to C and JVM.
Eiffel Forum Eiffel Archive with free software and lots of links.
Eiffel Liberty Journel Lots more links to all sorts of good OO references
Interactive Software Engineering Home page of the company that introduced Eiffel, with hundreds of pages of scholarly OO papers and EiffelBase, the open source library with 140 classes and thousands of methods
I'd appreciate more details on why you think ISE's IDE is so bad.
When I worked with EiffelBuild, IDE's GUI generator in 1994, it needed better support for multideveloper projects. And EiffelCase, IDE's CASE tool, hasn't completely supported the goal of seamless (from analysis through implementation) engineering and reengineering at the level that ISE enthusiasts would like. But these deficiencies are well outside what I think you are referring to in your IDE criticism, and they are deficiencies primarily because ISE has raised the standards.
I encourage /. readers to form their own opinions by going to ISE's web site and download EiffelBench, their IDE, for a free time limited trial. Of course, you can also use the language completely free with SmallEiffel, the GNU eiffel compiler.
Disclaimer: In 1994 I was employed on an Eiffel project through ISE, but my only relationship with them since then has been as a customer.
This anonymous coward is Tom Morrisette, eiffelpgmr@nni.com.
Then what are all the great Eiffel apps?
Where is long list of Eiffel success stories?
Can Eiffel match the success lists of
Python (much newer) or Smalltalk (with none of
the safety features so important in Eiffel)?
If Eiffel is so good to make reliable programs,
why do demos downloaded from ISE crash so much?
What are they, what do they do, what's their practical use?
Is it for end users or are they embedded in other software?
I've been hearing about them for a long time but still don't
know what they look like.
Perl may not be the most linguistically elegant language, but it's probably the only language out there that's actually delivered on the big promise of OOP: reusable code. A lot of this may have to do with the free software ethic of perl developers and a really good distribution mechanism (www.cpan.org), but whatever the reason it's nice not having to reinvent the wheel constantly. It's also interesting to note that most published perl code is in the form of reusable modules; writing a perl program then becomes a pretty trivial task of stringing together calls to them, so people don't even bother to publish scripts for the most part. Compare this to what gets published on the net for other languages. When you need to actually solve a problem, and quickly and portably, perl is a pretty big hammer.
Perl-- the "p" is for "practical", not "pure" or "pretty".
Check out "Artificial Intelligence A Modern Approach" by Russel & Norvig. It's probably the best general survey AI book out now. It has only one chapter devoted specifically to intelligent agents, but the underlying ideas get brought up in other chapters. It covers a lot of different topics within AI, but manages to convey a good amount of info on each topic (For example, the chapter on neural networks doesn't compare to the depth of information in say "Neural Network Design").
Personally, I really like this book, just don't assume it covers everything possible (Genetic Algorithms/Evolutionary stuff is missing, one of its downsides...)
Some example from my former company ... agents that roam around in a network to optimise the routing and / or to look for upcoming problems.
...
... yet. It's a pitty.
"Travel agents"; you want to go from A -> C with the famous B in the middle now what are the best connections. Agent (a) could ask agent (b) who knows some others and so on and so on
A example at BT, the "intelligent" electronic newspaper. An agent that learns what you are interested in, collects the information over the night and voila, in the morning there it is.
Java, with all is shortcomings, is yet probably the best to write stuff like that although there are frameworks on top of Java to build agents.
All in all very interesting stuff, although not that much in the limelight
Eiffel is undoubtedly a vast improvement over C++, but writing programs in it is arduous if you ask me. It seems like you have specify just about *everything*.
I think Dylan is a much productive language for most things.
Gwydion Dylan
Dylan descended from Lisp, but don't let that scare you away. It's got infix syntax, and it is fully OO from the ground up (much more so than Java). Just about everything is a first class object... methods... 'primitive' data types, even classes are objects.
(BTW, I'm a professional C++ developer...)
Dylan has real multiple inheritance, and it's not brain-dead like C++'s.
Dylan has static typing... but only when you want it. You can hack out a prototype without any type declarations, and then add them in later when you are optimizing for speed.
Dylan also has real macros, so you can add features to the language within the langauge. You also get keyword parameters, multiple dispatch, and a bunch of other great features... all in an easy-to-use and consistent and logical language.
Once you program in Dylan, you will never want to go back to Java, C++, or C.
Java isn't perfect... It's downright cruddy.
Any object-oriented language in which primitive types aren't objects needs some serious rethinking.
Dylan is a dynamic language, but when the programmer supplies type information, programs written in Dylan can perform really well (C++ speed). Dylan has many advanced features which make programming easier and more productive.
Free open-source version at
http://gwydiondylan.org
Free commercial version at
http://www.harlequin.com/products/ads/dylan/
Java is the most over-hyped language on the planet.
Check out http://www.tunes.org/Review/Languages.html
and read the section on Java. It is straight-on.
Now Dylan is a cool language.
Meept likes books. There is nothing meept likes more than the smell of an old book. Like the bible.
MEEPT!!
Web agents I think are not usually considered intelligent agents.
We use intelligent agents in modeling problems and they simulate people. They are programmed with relatively simple rules and they interact with each other and sometimes learn (which would make them adaptive intelligent agents).
Can't model a real world problem without real world data. Duh.
You are using what might be the only serious application written in Objective C. It is not a gap in your education that you never used Objective C before.
If Swarm were ported to C++ and were allowed some kind of i-o with a database it might actually become an application that people used to solve real problems using real data. Until that time it will remain a strictly "academic" application.
I read it, but I don't understand it. It says that Java is bloated?! Definately not, I MISS features like templates/generic objects and multiple inheritance, multi-methods...
The lack of features in Java makes programming unneccessary complicated (at least for people who use it >40hrs/week, if you want to write 1000 line programs your needs will be different).
I don't have the any practical experience with Dylan, but after reading the Dylan Language I had the impression that it was not very suited for designing big programs. I don't like its hybrid-oop concept (seperating methods from objects), it is even worse than Java's hybrid concept, and I cannot imagine how to design programs in a object-oriented way. It feels more like a functional language with object-oriented structures, and I don't like functional programming.
Java is almost perfect for intelligent agents, it is incredible easy to do things like serialization or remote communication (rmi) with Java. You can do this with Perl or C++, but is it complicated and not integrated in the basic libraries. Also, most agent frameworks are written for Java (Voyager is a very good example, www.objectspace.com) and Java's platform independence really makes sense for agents.
Perhaps most important, agents fit very, very well into the whole OOP idea (one agent = one object), and Perl's OOP capabilities suck by the way.
Yes, but these Wrapper Objects make everything complicated. Smalltalk is much more comfortable without losing speed in this aspect.
Voyager is an ORB-and-more distributed computing toolkit for Java, and it lets you create an agent very simply. For example to turn any object into an agent and move it to another host, where it will execute some method:
:).
Agent.of( myObject ).moveTo( remoteHost, method );
Voyager will move the agent to remoteHost and execute the given method upon arrival.
Voyager Core Technology is free to download/use. Check out http://www.objectspace.com for more.
And no, it doesn't come with source code, but it's still a cool product. And they don't pay me to say that
Since when do intelligent agents rip apart HTML documents ? Come to think of it, what does the reviewer think intelligent agents are ?
My experience is that 'agent' tends to refer to programs given an 'AI-type' task by a user, which they then perform, possibly by moving themselves over the network.
I think the whole idea is a bit naff - thats probably why it is hard to define, but I certianly don't think code examples in C++ or Perl are a good idea. They are hard to read, hard to translate into other languages and non-portable.
PS. Smalltalk is cool
These are my friends, and my old place of work, so...
If you want the definative place to see research on Agents and related technologies, see the M.I.T. Media Lab.
Specifically, the following three groups:
There are always four sides to every story: your side, their side, the truth, and what really happened.
C++ allows templates which allow generic variables. Java lacks this feature, which is very much needed.
Smalltalk does not need generics because everything is generic! So what if Smalltalk is dynamically typed? It may be SLOW, but dynamic typing allows cool stuff like interpratation and clock constucts.
--Ivan, weenie NT4 user, Jon Katz hater: bite me!
--weenie NT4 user: bite me!
"Computers are nothing but a perfect illusion of order" -- Iggy Pop
And probably for good reasons. Portability, Built-in networking, GC, RMI and so on make Java development and deployment of agents on multiple platforms easy.
Follow the Black Valley Trail of Death,
Follow the Black Valley Trail of Death,
Into the Beautiful Sunshine.
Huh?
MEEPT
Actually my personal beef with smalltalk has nothing to do with speed. Speed is, IMHO, the most over rated and mis-optimized thing in programming. If programmers (myself included, I've been a hacker since the early days when speed mattered. Those habits die hard) paid more attention to the usability/productivity/efficiency of the system and less to how quickly routine n could run through the CPU then perhaps we would be using better designed applications that allow us to get a task done in three steps that are CPU wasteful but complete the task more quickly than 5 steps of highly optimized code.
I think as a community there is a lot of focus on the wrong issues.
Woops, I'm ranting. To get back to your point about dynamic typing.
My beef is that it turns application users into testers. The axiom 'you can't test quality into a system' is amplified by anything that takes the typing out of the language and relies more heavily on either the programmers skills or fanatical testing to find problems in the system.
Since programmers aren't smart enough to grok (in the strong sense of the word) the complexity of anything but the most trivial application the responsibility falls on the test team to provide really exceptional coverage in their tests. That never happens (see the axiom above) so the user ends up finding significant problems, often after the system has been deployed.
Not a book, but Liz Kendall has written some really wonderful stuff on the subject. Check:
http://www.cse.rmit.edu.au/~rdsek/
Especially the layer agent pattern.
That isn't the only power. Two other significant ones are:
1) You can get a stable, standard compliant c++ compiler for just about any platform. Java is still an infant.
2) Java lacks any concept of genericity and Smalltalk lacks typing. I don't care to get into a fundementals of OO here since most people aren't interested, but for people who value the chance to have the compiler find many of their blunders and value the ability to express code in a generic fashion C++ is currently the only game in town.
Having said that I program in Python and Java regularly and Smalltalk with less frequency. IOW, I'm not a language bigot claiming that C++ is that ultimate hammer, but I wanted to correct the statement that the speed of a compiled language is its only advantage to using it.
Um.. Speed still does matter quite a bit in many artificial intelligence applications. I guess you guys haven't tried simulating any large neural networks lately, eh?
Sam
Well, I wasn't intending to offend you. I was merely trying to point out an area which I happen to be trying to work on with intelligent agents. Since the recommendation was for a language to use with intelligent agents I thought it was particularly relevant.
Sam
Err... In my experience, intelligent agents spend a lot of time ripping apart HTML. While agents will not doubt be more advanced in the future, right now they basically cruise the web looking for information. I don't think Perl is appropriate as the language for the neural nets or expert systems in the agent but it is very easy to use to extract URLs, find keyword proximity, etc.
I understand the authors omittance of Perl. I was just trying to point out that it could be useful for agent development today.
Sam
For neural networks, my favorite is Haykin's Neural Networks: A Comprehensive Foundation. Be aware that it is very theoretical and goes through a lot of mathematical background and proofs.
For intelligent agents specifically there just aren't many good ones.
Sam
Well, I must apologize to all those smalltalk enthusiasts out there. I'm really probably not familiar enough with the language to pass judgement on it. The only experience I've had with it was back in a Concepts of Programming Languages course. I wasn't meaning to dis smalltalk just say that C++ seemed to be up to the task for now ; )
Sam
Could a few people recommend their favorite books on this subject, by way of comparison?
There is also Standard ML: strongly typed, good module system, better implementation/interface separation then C++...
> I don't care to get into a fundementals of OO here since most people aren't interested, but for people who value the chance to have the compiler find many of their blunders and value the ability to express code in a generic fashion C++ is currently the only game in town.
Another thing that I found annoying is the authors' exuberance for Smalltalk and Java and their downplaying the power of C++.
:it | withStyle]
The only power of C++ is that it runs faster since you compile directly to the native OS byte code. Other than that, it's just an imperative language with OO built on top of it.
For AI, or knowledge representation, more reflective languages like Smalltalk fare much better. AI is not rexeps, therefore why would the author use Perl? Java and many dialects of Smalltalk have builtin classes for networking, making the distrubuted part a cinch.
Smalltalkers do: [
--Ivan, weenie NT4 user, Jon Katz hater: bite me!
--weenie NT4 user: bite me!
"Computers are nothing but a perfect illusion of order" -- Iggy Pop