PyTri is a Python based visual agent programming language which has been designed top-down to utilize the possibilities of graphical representation of control ow by amending the concepts of Petri nets. Its main inspiration, Mulan, which is based on Java nets, originated bottomup from a powerful formalism, which allows modeling and programming multi-agent systems. The here presented PyTri vision uses multiple types of transitions and places, with a specialized Python-based inscription language, in order to o er a rich semantics that allows expressive and compact representation of executable code. GUI widgets can be directly embedded into the nets and can infuse them with tokens upon user interaction. PyTri aims to support coarsening mechanisms, instead of the net within net paradigm, and includes a special place class that allows representation of independent control ow streams. It strives to enable modularization of complex multi-agent applications as one huge at structure, not requiring them to be separated into discrete layers. Integral to PyTri is a future tool for visualization and manipulation which is tailored to the needs of programmers using the language.
Visual Languages o er more modalities[
Petri nets o er a very intuitive way of representing arbitrary computation processes by decomposing them into atomic actions and intermediate chunks of data, incorporated by transitions and places. By embedding external triggers into a net, reactive programming can be done without the hassle of splitting up the code into steps.
The human mind in general is very good at memorizing structures visually, grouping related objects by spatial proximity. There are several types of UML diagrams which are a popular method to visualize the interrelations of the classes and objects of an application. By modeling an application with a Petri net like net formalism in one single huge structure, the big picture can be shown as a direct map of the internal processes, possibly even in three dimensions. Of course, mechanisms of coarsening have to be used, in addition to modularizing the code into organ-like fragments, or none would be able to cope with the complexity.
In [
In Section 2 the mission statement for PyTri, the aims of its semantics, and the most important properties of its formalism are given. Section 3 introduces the idea of specialized types of places and transitions, a mixed class of elements, PyTri's focus on coarsening and re nement, and tool support. Section 4 discusses the results of the design of PyTri and future work. 2
PyTri aims to be an expressive and compact language, condensing common programming tasks to a clean and descriptive representation. PyTri has been designed from the start with the goal of making the creation of multi-agent based applications as comfortable as possible. Essential to PyTri is an extensive graphical editor displaying the net code, designed for developing, debugging and manipulating. The concepts of PyTri have been designed top-down with a focus on programming, not modeling. PyTri aims to employ a rather complex semantics, and is targeted at experienced programmers willing to learn its large vocabulary. It still tries to be intuitive, without dumbing down, in order to be accessible to novices, given a set of good tutorials, gradually introducing the concepts.
The Java net formalism has some assembler like aspects to it, because one has to perform a lot of bookkeeping by hand to perform basic tasks. The formalism of PyTri attempts to take graphical programming to a higher level of abstraction, retaining a semantics that is very similar to that of Petri nets, but di ering in several important ways, still including elements that act very much like traditional places and transitions. Rather than having one kind of place and transition that is used for everything, the formalism is based on specialized elements that are the basic primitives of the language and can be compared to statements in textual languages, like if, while, try, def or return.
In order to allow compact branching of control ow, the PyTri formalism deviates from the Petri net semantics by allowing transitions to dynamically decide to suppress the donation of tokens to speci c target places. This means that the actual control ow is no longer apparent from the arc connections alone, but dependent on the inscriptions of the transitions. Such conditional branching would su ce, and may be the best solution in some cases, but in other cases having a specialized transition type, with a di erent inscription semantics, can be useful syntactic sugar and convey the intention of the code in a better way. An example is the Switch transition shown in Figure 1, which can be used to evaluate an expression and donate a token only through the arc whose inscription matches, or can evaluate a set of arcs inscribed with boolean expressions and independently donate tokens through all those that are true.
PyTri's inscription language is based on Python, which was chosen because it is a very compact and powerful high-level language and o ers a great standard library. It is attempted to allow almost arbitrary Python code in the inscriptions, while amending the inscription language with the required new concepts, pythonically. It uses pythonic duck typing, where Java nets guarantee that only certain types of objects can traverse an arc. A lot of the expressiveness of Java nets comes from uni cation, which allows fully dynamic connections between elements. PyTri aims for a simpler and easier to understand semantics, which introduces other mechanisms to cope with the loss of the prolog-like power. 3
Place Types. Just like in Petri nets and Java nets, places are passive and do not initiate actions by themselves, however, they are preconditions to the transitions that accept tokens from them. Instead of having one general kind of place which is used universally to store data, PyTri o ers several types. Usually, places are either used to store a single token or to store a collection of tokens, rarely both.
When storing single tokens, places are usually used either for signifying and determining the control ow, or as a single variable holding intermediate or persistent data objects, which leads to the place types Flow and Variable.
When storing a collection of tokens, one usually wants it to behave like one common abstract data type, depending on the context. By incorporating the required behavior in a place type, Queue or Stack for example, the programmer can be spared of the otherwise necessary manual bookkeeping. Also, special place types can exist simply to provide helpful eye candy to the developer, or simplify debugging of agents by easing the assignment of the states an agent can be in. Transition Types. Many abstract mechanisms integral to programming are not atomic, but are composed of multiple steps. By having basic elements that execute multiple atomic phases when needed, while storing internal data, the language becomes more compact in its expressiveness. Those elements of this kind, which in essence are transition-bordered components, can be considered similar enough in concept to transitions to justify raising them to their level. Through this the concept of transitions is extended to a set of basic graphical statements building the core language. Since the individual phases are still atomic, complex multi-phase transitions should be decomposable to nets of places and atomic transitions. This decomposition however can also be virtual, since the behavior may be implemented through pure Python objects with a certain interface.
Some transition types require special interactions with certain types of places in order to achieve their purpose. Some transitions work like components built out of elements connected to other transitions via virtual arcs. PyTri has been designed from the start with the aim of creating a language tailored to the creation of multi-agent systems. Amongst the basic transitions are elements that allow sending messages to other agents, receiving messages, or a combination. Gadgets. In order to directly embed GUI components into the nets, a new general type of element was devised. Gadgets are the representation for mixed-border components, which can perform proactive actions, but also expose their internal data to connected transitions, like a place. The internal virtual elements of a gadget are connected to the elements around it, based on the aliases of the connecting arcs. Gadgets have a consistent semantics that enables them to directly interact with the surrounding net by donating tokens, acting as a precondition, and receiving tokens. For GUI components, the behavior can be encapsulated in pure Python proxy objects that perform all required bookkeeping transparently. In Figure 2, a dialog is visible and tangible to a local user, as long as a token is inside the leftmost place. When one of the two buttons is pressed, the dialog hides, consumes the rst token and donates a new token through the matching arc. As a result, either the user name is copied into the net, or the agent terminates. Coarsening. The main mechanism of modularization in Java nets is the nets within nets approach, since places can contain net objects. Contained nets can interact, through their own internal transitions, with outer transitions connected to their place, using synchronous channels. However, this approach introduces a sharp partitionment of the code into layers, resulting in a break of continuity.
PyTri favors a at structure where all elements are on one universal layer, and other mechanisms for partitioning are used instead. Some control ows need to be executed in multiple independent instantiations, for example protocols that control interactions between agents. Instead of instantiating protocol nets as is done in Mulan, such code can be modeled through a new class of place. Parallel places transparently manage all bookkeeping necessary to atten the behavior into a single structure, where tokens move in independent streams, separating the structure into virtual instances. Such places can also give an informational summary of all independent streams to the developer, during execution. This mechanism can be enhanced to allow piecing together net structures that look like AUML diagrams.
Coarsening and re nement of nets is a very powerful mechanism to make big structures controllable. By allowing to collapse and expand collections of elements forming a component, one can choose the optimal level of detail of the representation of the code. This can be used to modularize the code and the resulting segments can be coarsened to look just like normal elements. An interface for such a segment can be de ned by specifying which of the contained elements are accessible through certain aliases. Depending on whether only places, transitions, or both are accessible, segments are represented as such an element, in the mixed case as a gadget.
Tool Support. An integral part of PyTri is having tool support for the language, namely a Monipulator that allows creation, manipulation, monitoring and debugging of net code. In order to allow developers to separate big nets into manageable chunks, they can be partitioned into fragments, which are joined into a at whole net, maintaining the original semantics.
The preliminary maxim of PyTri, which arose due to the global interpreter lock of Python, is that every agent is its own process. There is no global simulator process that contains, manages and controls agents. Memory is not shared between agents, which have to rely on interprocess-interaction, facilitated by a process present on every machine of a distributed environment. 4
Programing complex systems remains a challenge. This paper provides a vision
in form of a new graphical programming language to address this problem. PyTri
overcomes some drawbacks of the successful extension of Java in the form of
reference nets with agent concepts from Mulan. It does so by amending a di erent
language, namely Python, and adding several new or adapted constructs and
concepts to the language with respect to the graphical underpinning. While it is
strongly in uenced by Petri nets, its semantics is adapted to the requirements of
programming and explores a lot of di erent possible programming mechanisms,
in order to investigate the realm of possibility. This allows for powerful expression
of behavior through new constructs and concepts. PyTri's concepts, the
prototypical implementation, written in Stackless Python, using PyQt, and the whole
background of the language has been intensively discussed in [
Our current direction of research is now to provide a proper Petri net semantics for the current concepts and constructs. Concepts and experiences from reference nets, Renew and Mulan/Capa will give further directions of development beside the direct evaluation of the current PyTri tool set. The main goal is to keep and extend PyTri as a powerful modeling and programming language while trying to regain the analytical power of Petri nets, which is currently lost. In order to truly seize the power of a language which directly expresses concurrency, a di erent implementation base for the execution core and the inscription language has to be considered, possibly based on PyPy or C++. Besides PyTri as a language, the tools around PyTri will also be subject to several di erent investigations. In the future, a series of prototypes, no longer based on Stackless, which gradually implement more and more concepts of the language, will be created. Here concrete, at the beginning rather arti cial applications will further help to nd the right modeling and programming concepts.