Follow Slashdot stories on Twitter

 



Forgot your password?
typodupeerror
News Books Media Book Reviews

Review:Developing Intelligent Agents for Distributed Systems 37

Sam Mulder sent a review of Michael Knapik and Jay Johnson's Developing Intelligent Agents for Distributed Systems. A book for those taking a high level view of intelligent agents. Click below for more information.
Developing Intelligent Agents for Distributed Systems
author Michael Knapik and Jay Johnson
pages
publisher McGraw-Hill
rating 6
reviewer Sam Mulder
ISBN
summary This is a high level overview of intelligent agents that is suitable for someone getting started in the field.

The Scenario

Knapik and Johnson attempt to provide an overview on the field of intelligent agents. They claim to cover "virtually all aspects of intelligent agent technology." They do cover a wide variety of topics such as object orientation in at least enough detail to get started. Other areas such as artificial intelligence are just too broad for them to discuss at any useful level.

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

  1. Introduction
  2. From Artificial Intelligence Comes Intelligent Agents
  3. Converging Technologies that Facilitate and Enable Agents
  4. Agent-Enabling Infrastructures
  5. Agent Architectures
  6. Agent Design Considerations
  7. Developing Intelligent Agents Now
  8. Agent Applications
  9. Agent Futures
This discussion has been archived. No new comments can be posted.

Review:Developing Intelligent Agents for Distributed Systems

Comments Filter:
  • 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 [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 [mit.edu].

    Specifically, the following three groups:

  • 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!
  • 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,
  • Huh?

    MEEPT
  • 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.

    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.

  • by rw2 ( 17419 )
    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.
  • 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.

    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
  • by cdj ( 18691 )
    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++.

    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: [ :it | withStyle]


    --Ivan, weenie NT4 user, Jon Katz hater: bite me!

"A mind is a terrible thing to have leaking out your ears." -- The League of Sadistic Telepaths

Working...