Skip to main content
SpringerLink
Log in
Book cover

Encyclopedia of Complexity and Systems Science pp 1–28Cite as

Agent-Based Modeling and Computer Languages

  • Living reference work entry
  • First Online:

  • 394 Accesses

Definition: Agent-Based Modeling and Computer Languages

Agent-based modeling is a bottom-up approach to representing and investigating complex systems. Agent-based models can be implemented either computationally (e.g., through computer simulation) or non-computationally (e.g., with participatory simulation). The close match between the capabilities of available software and the requirements of agent-based modeling make these options a natural choice for many agent-based models. Of course, realizing the potential benefits of this natural match necessitates the use of computer languages to express the designs of agent-based models. A wide range of computer design and programming languages can play this role including both domain-specific and general-purpose languages. The domain-specific languages include business-oriented languages (e.g., spreadsheet programming tools), science and engineering languages (e.g., Mathematica), and dedicated agent-based modeling languages (e.g., NetLogo)....

This is a preview of subscription content, log in via an institution.

Abbreviations

Agent:

An agent is a self-directed component in an agent-based model.

Agent-Based Model:

An agent-based model is a simulation made up of a set of agents and an agent interaction environment.

Annotations:

Annotations are a Java feature for including metadata in compiled code.

Aspects:

Aspects are a way to implement dispersed but recurrent tasks in one location.

Attributes:

Attributes are a C# feature for including metadata in compiled code.

Bytecode:

Bytecode is compiled Java binary code.

C#:

C# (Archer 2001) is an object-oriented programming language that was developed and is maintained by Microsoft. C# is one of many languages that can be used to generate Microsoft.NET Framework code. This code is run using a “virtual machine” that potentially gives it a consistent execution environment on different computer platforms.

C++:

C++ is a widely used object-oriented programming language that was created by Bjarne Stroustrup (Stroustrup 2008) at AT&T. C++ is widely used for both its object-oriented structure and its ability to be easily compiled into native machine code.

Class:

A class is the object-oriented inheritable binding of procedures and data that provides the basis for creating objects.

Common Intermediate Language:

Common Intermediate Language (CIL) is compiled binary code for the Microsoft.NET Framework. CIL was originally called Microsoft Intermediate Language (MSIL).

Computational Algebra Systems:

Computational Algebra Systems (CAS) are computational mathematics systems that calculate using symbolic expressions.

Computational Mathematics Systems:

Computational Mathematics Systems (CMS) are software programs that allow users to apply powerful mathematical algorithms to solve problems through a convenient and interactive user interface. CMS typically supply a wide range of built-in functions and algorithms.

Computer Language:

A computer language is a method of specifying directives for computers. Computer programming languages, or more simply programming languages, are an important category of computer languages.

Computer Programming Language:

Please see the entry for “Programming Language.”

Declarative Language:

According to Watson (1989) a “declarative language (or non-procedural language) involves the specification of a set of rules defining the solution to the problem; it is then up to the computer to determine how to reach a solution consistent with the given rules.”

Design Pattern:

Design patterns form a “common vocabulary” describing tried-and-true solutions for commonly faced software design problems (Coplien 2001).

Domain-Specific Language:

Domain-specific languages (DSLs) are computer languages that are highly customized to support a well-defined application area or “domain.” DSLs commonly include a substantial number of keywords that are nouns and verbs in the area of application as well as overall structures and execution patterns that correspond closely with the application area.

Dynamic Method Invocation:

Dynamic method invocation, combined with reflection, is a Java and C# approach to higher-order programming.

Encapsulation:

Encapsulation is the containment of details inside a module.

Field:

A field is a piece of object-oriented data.

Function Pointers:

Function pointers are part of C++’s approach to higher-order programming. Runtime Type Identification is another component of this approach.

Functional Language:

According to Watson (1989) “in functional languages (sometimes called applicative languages) the fundamental operation is function application.”

Generics:

Generics are a Java and C# feature for generalizing classes.

Goto Statement:

A goto statement is an unconditional jump in a code execution flow.

Headless:

A headless program executes without the use of a graphical user interface or video monitor. This is generally done to rapidly execute models while logging results to files or databases.

Higher-Order Programming:

According to Reynolds (1998), higher-order programming involves the use of “procedures or labels…as data” such that they “can be used as arguments to procedures, as results of functions, or as values of assignable variables.”

Imperative Language:

According to Watson (1989) in imperative languages “there is a fundamental underlying dependence on the assignment operation and on variables implemented as computer memory locations, whose contents can be read and altered.”

Inheritance:

Inheritance is the ability of an object-oriented class to assume the methods and data of another class called the parent class.

Java:

Java (Foxwell 1999) is a widely used object-oriented programming language that was developed and is maintained by Oracle Corporation. Java is known for its widespread cross-platform availability on many different types of hardware and operating systems. This capability comes from Java’s use of a “virtual machine” that allows code to have a consistent execution environment on many different computer platforms.

Logic Programming Language:

According to Watson (1989) “in a logic programming language, the programmer needs only to supply the problem specification in some formal form, as it is the responsibility of the language system to infer a method of solution.”

Macro Language:

Macro languages are simple domain-specific languages that are used to write scripts for tools such as spreadsheets.

Mathematica :

Mathematica is a commercial software program for computational mathematics. Information on Mathematica can be found at http://www.wolfram.com/

MATLAB:

The MATrix LABoratory (MATLAB) is a commercial software program for computational mathematics. Information on MATLAB can be found at http://www.mathworks.com/

Method:

A method is an object-oriented procedure.

Methodological Individualism:

A reductionist approach to social science originally developed by Max Weber that focuses on the interaction of well-defined and separate individuals (Heath 2005). Alternative theories usually focus on more holistic views of interaction (Heath 2005).

Mobile Agents:

Mobile agents are lightweight software proxies that roam the World Wide Web and perform various functions programmed by their owners such as gathering information from Web sites.

Module:

According to Stevens et al. (1974), “the term module is used to refer to a set of one or more contiguous program statements having a name by which other parts of the system can invoke it and preferably having its own distinct set of variable names.”

NetLogo:

NetLogo (Wilensky 1999) is an agent-based modeling and simulation platform that uses a domain-specific language to define models. NetLogo models are built using a metaphor of turtles as agents and patches as environmental components (Wilensky 1999). NetLogo is Java based. NetLogo is free for use in education and research. More information on NetLogo and downloads can be found at http://ccl.northwestern.edu/netlogo/

Non-procedural Language:

Please see the entry for Declarative Language.

Object:

An object is the instantiation of a class to produce executable instances.

Objective-C:

Objective-C is an object-oriented language that extends the C language.

Object-Oriented Language:

Object-oriented languages are structured languages that have special features for binding data with procedures, inheritance, encapsulation, and polymorphism. Careful abstraction that avoids unnecessary details is an important design principle associated with the use of object-oriented languages.

Observer:

The observer is a NetLogo agent that has a view of an entire model. There is exactly one observer in every NetLogo model.

ODD Protocol:

Describes models using a three-part natural language approach: overview, concepts, and details (Grimm et al. 2006).

Patch:

A patch is a NetLogo agent with a fixed location on a master grid.

Polymorphism:

Polymorphism is the ability of an object-oriented class to respond to multiple related messages, often method calls with the same name but different parameters.

Procedural Language:

According to Watson (1989) “procedural languages…are those in which the action of the program is defined by a series of operations defined by the programmer.”

Programming Language:

A programming language is a computer language that allows any computable activity to be expressed.

Record:

A record is an independently addressable collection of data items.

Reflection:

Reflection, combined with dynamic method invocation, is a Java and C# approach to higher-order programming.

ReLogo:

An object-oriented Logo implementation in Repast Simphony.

Repast:

The Recursive Porous Agent Simulation Toolkit (Repast) is a free and open source family of agent-based modeling and simulation platforms (ROAD 2013). Information on Repast and free downloads can be found at http://repast.sourceforge.net/

Repast Simphony:

Repast Simphony is the member of the Repast Suite of free and open source agent-based modeling and simulation software (North et al. 2013). The Java-based Repast Simphony system includes advanced features for specifying, executing, and analyzing agent-based simulations.

Runtime Type Identification:

Runtime Type Identification (RTTI) is part of C++’s approach to higher-order programming. Function pointers are another component of this approach.

Structured Language:

Structured languages are languages that divide programs into separate modules, each of which has one controlled entry point, a limited number of exit points, and no internal jumps (Dijkstra 1968).

Swarm:

Swarm (Swarm Development Group 2013) is a free and open source agent-based modeling and simulation library maintained by the Swarm Development Group. The core Swarm system uses Objective-C. A Java-based “Java Swarm” wrapper for the Objective-C core is also available. Information on Swarm and free downloads can be found at http://www.swarm.org/

Templates:

Templates are a C++ feature for generalizing classes.

Turtle:

A turtle is a mobile NetLogo agent.

Unified Modeling Language:

The Unified Modeling Language (UML) is a predominantly visual approach to specifying the design of software (Object Management Group 2001, Object Management Group 2013) that consists of a variety of diagram types.

Unstructured Language:

Unstructured languages are languages that rely on step-by-step solutions such that the solutions can contain arbitrary jumps between steps.

Virtual Machine:

A virtual machine is a software environment that allows user code to have a consistent execution environment on many different computer platforms.

Bibliography

  • Alexander C (1979) The timeless way of building. Oxford University Press, Oxford

    Google Scholar 

  • Alexander C, Ishikawa S, Silverstein M (1977) A pattern language. Oxford University Press, Oxford

    Google Scholar 

  • Archer T (2001) Inside C#. Microsoft Press, Redmond

    Google Scholar 

  • Backus J, Bauer F, Green J, Katz C, McCarthy J, Naur P, Perlis A, Rutishauser H, Samuelson K, Vauquois B, Wegstein J, van Wijngaarden A, Woodger M (1963) Revised report on the algorithmic language ALGOL 60. In: Naur P (ed) Communications of the association for computing machinery (ACM), vol 6. ACM, New York, pp 1–17

    Google Scholar 

  • Bhavnani R (2003) Adaptive agents, political institutions and civic traditions in modern Italy. JASSS 6(4). Available at http://jasss.soc.surrey.ac.uk/6/4/1.html

  • Bonabeau E (2001) Agent-based modeling: methods and techniques for simulating human systems. Proc Natl Acad Sci 99(3):7280–7287

    ADS  Google Scholar 

  • Casti J (1997) Would-be worlds: how simulation is changing the world of science. Wiley, New York

    MATH  Google Scholar 

  • Coplien J (2001) Software patterns home page. Available at http://hillside.net/patterns/

  • Dahl O-J, Nygaard K (1966) SIMULA – an ALGOL-based simulation language. Commun ACM 9:671–678

    Article  MATH  Google Scholar 

  • Dahl O-J, Nygaard K (2001) How object-oriented programming started. Available at http://heim.ifi.uio.no/~kristen/FORSKNINGSDOK_MAPPE/F_OO_start.html

  • Daniels M (1999) Integrating simulation technologies with swarm. In: Proceedings of the agent 1999 workshop on agent simulation: applications, models, and tools. Argonne National Laboratory, Argonne

    Google Scholar 

  • Dijkstra E (1968) Go to statement considered harmful. Commun ACM 11(3):147–148

    Article  MathSciNet  Google Scholar 

  • Eclipse (2013) Eclipse home page. Available at http://www.eclipse.org/

  • Foxwell H (1999) Java 2 software development kit. Linux J

    Google Scholar 

  • Gamma E, Helm R, Johnson R, Vlissides J (1995) Design patterns: elements of reusable object-oriented software. Addison-Wesley, Wokingham

    Google Scholar 

  • Gaylord R, D’Andria L (1998) Simulating society: a Mathematica toolkit for modeling socioeconomic behavior. Springer/TELOS, New York

    Book  MATH  Google Scholar 

  • Gaylord R, Davis J (1999) Modeling nonspatial social interactions. Math Educ Res 8(2):1–4

    Google Scholar 

  • Gaylord R, Nishidate K (1994) Modeling nature: cellular automata simulations with Mathematica. Springer, New York

    Google Scholar 

  • Gaylord R, Wellin P (1995) Computer simulations with Mathematica: explorations in complex physical and biological systems. Springer/TELOS, New York

    MATH  Google Scholar 

  • Grimm V et al (2006) A standard protocol for describing individual-based and agent-based models. Ecol Model 198(1–2):115–126

    Article  Google Scholar 

  • Guetzkow H, Kotler P, Schultz R (eds) (1972) Simulation in social and administrative science. Prentice Hall, Englewood Cliffs

    Google Scholar 

  • Harvey B (1997) Computer science logo style. MIT Press, Boston

    Google Scholar 

  • Heath J (2005) Methodological individualism. In: Zalta E (ed) Stanford encyclopedia of philosophy. Stanford University, Stanford. Available at http://plato.standford.edu/

  • Jennings N (2000) On agent-based software engineering. Artif Intel 117:277–296

    Article  Google Scholar 

  • Koenig D, Glover A, King P, Laforge G, Skeet J (2007) Groovy in action. Manning Publications, Greenwich

    Google Scholar 

  • Lahtinen E, Ala-Mutka K, Jarvinen H-M (2005) A study of the difficulties of novice programmers. In: Proceedings of the 10th annual SIGCSE conference on innovation and technology in computer science education. ACM, Caparica

    Google Scholar 

  • Macal C (2004) Agent-based modeling and social simulation with mathematica and MATLAB. In: Macal C, Sallach D, North M (eds) Proceedings of the agent 2004 conference on social dynamics: interaction, reflexivity and emergence. Argonne National Laboratory, Argonne

    Google Scholar 

  • Macal C, Howe T (2005) Linking repast to computational mathematics systems: Mathematica and MATLAB. In: Macal C, Sallach D, North M (eds) Proceedings of the agent 2005 conference on generative social processes, models, and mechanisms. Argonne National Laboratory, Argonne

    Google Scholar 

  • Macal C, North M (2007) Agent-based modeling and simulation: desktop ABMS. In: Henderson SG, Biller B, Hsieh M-H, Shortle J, Tew JD, Barton RR (eds) Proceedings of the 2007 winter simulation conference. IEEE/ACM, Washington, DC

    Google Scholar 

  • McCarthy J (1960) Recursive functions of symbolic expressions and their computation by machine I. J ACM 3:184–195, ACM, New York, NY, USA

    Article  MATH  Google Scholar 

  • Minar N, Burkhart R, Langton C, Askenazi M (1996) The swarm simulation system: a toolkit for building multi-agent simulations. Available at http://alumni.media.mit.edu/~nelson/research/swarm/

  • North M, Macal C (2007) Managing business complexity: discovering strategic solutions with agent-based modeling and simulation. Oxford University Press: New York, NY, USA

    Google Scholar 

  • North M, Macal C (2011) Product design patterns for agent-based modeling. In: Jain S, Creasey R, Himmelspach J (eds) Proceedings of the 2011 winter simulation conference. IEEE/ACM, Phoenix

    Google Scholar 

  • North M, Macal C (2013) Product and process patterns for agent-based modeling and simulation. J Simulat 8:25–36

    Google Scholar 

  • North M, Collier N, Vos R (2006) Experiences creating three implementations of the repast agent modeling toolkit. In: ACM transactions on modeling and computer simulation, vol 16, Issue 1. ACM, New York, pp 1–25

    Google Scholar 

  • North M, Collier N, Ozik J, Tatara E, Altaweel M, Macal M, Bragen M, Sydelko P (2013) Complex adaptive systems modeling with repast simphony. In: Complex adaptive systems modeling. Springer, Heidelberg

    Google Scholar 

  • Object Management Group (2001) OMG unified modeling language specification version 1.5. Object Management Group, Needham

    Google Scholar 

  • Object Management Group (2013) Object management group UML home page. Object Management Group, Needham

    Google Scholar 

  • Pearson D, Boudarel M-R (2001) Pair interactions: real and perceived attitudes. JASSS 4(4). Available at http://www.soc.surrey.ac.uk/JASSS/4/4/4.html

  • Reynolds J (1998) Definitional interpreters for higher-order programming. In: Higher-order and symbolic computation. Kluwer, Dordrecht, pp 363–397

    Google Scholar 

  • ROAD (2013) Repast home page. Available at http://repast.sourceforge.net/

  • Sedgewick R (1988) Algorithms, 2nd edn. Addison-Wesley, Reading, p 657

    Google Scholar 

  • Springer G, Freeman D (1989) Scheme and the art of programming. McGraw-Hill, New York

    Google Scholar 

  • Stevens W, Meyers G, Constantine L (1974) Structured design. IBM Syst J 13(2):115

    Article  Google Scholar 

  • Stroustrup B (2008) Bjarne Stroustrup’s FAQ. Available at http://www.research.att.com/~bs/bs_faq.html#invention

  • Swarm Development Group home page (2013) Available at http://www.swarm.org/

  • Thorngate W (2000) Teaching social simulation with MATLAB. JASSS 3(1). Available at http://www.soc.surrey.ac.uk/JASSS/3/1/forum/1.html

  • Thoyer S, Morardet S, Rio P, Simon L, Goodhue R, Rausser G (2001) A bargaining model to simulate negotiations between water users. JASSS 4(2). Available at http://www.soc.surrey.ac.uk/JASSS/4/2/6.html

  • Van Roy P, Haridi S (2004) Concepts, techniques, and models of computer programming. MIT Press, Cambridge

    Google Scholar 

  • Wang Z, Thorngate W (2003) Sentiment and social mitosis: implications of Heider’s balance theory. JASSS 6(3) Available at http://jasss.soc.surrey.ac.uk/6/3/2.html

  • Watson D (1989) High-level languages and their compilers. Addison-Wesley, Wokingham

    MATH  Google Scholar 

  • Wilensky U (1999) NetLogo http://ccl.northwestern.edu/netlogo/. Center for connected learning and computer-based modeling, Northwestern University, Evanston

  • Wolfram Research (2013) Mathematica home page. Available at http://www.wolfram.com/

Download references

Author information

Authors and Affiliations

  1. Argonne National Laboratory, Global Security Sciences Division, Argonne, IL, USA

    Michael J. North

Authors
  1. Michael J. North
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Charles M. Macal
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Michael J. North .

Editor information

Editors and Affiliations

  1. Ramtech Ltd., Larkspur, California, USA

    Robert A. Meyers

Rights and permissions

Reprints and permissions

Copyright information

© 2014 Springer Science Business Media New York (outside the USA)

About this entry

Cite this entry

North, M.J., Macal, C.M. (2014). Agent-Based Modeling and Computer Languages. In: Meyers, R. (eds) Encyclopedia of Complexity and Systems Science. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-27737-5_8-5

Download citation

  • DOI: https://doi.org/10.1007/978-3-642-27737-5_8-5

  • Received:

  • Accepted:

  • Published:

  • Publisher Name: Springer, Berlin, Heidelberg

  • Online ISBN: 978-3-642-27737-5

  • eBook Packages: Springer Reference Physics and AstronomyReference Module Physical and Materials ScienceReference Module Chemistry, Materials and Physics

Publish with us

Policies and ethics

Search

Navigation