Azimuth News (Part 2)

Last week I finished a draft of a book and left Singapore, returning to my home in Riverside, California. It’s strange and interesting, leaving the humid tropics for the dry chaparral landscape I know so well.

Now I’m back to my former life as a math professor at the University of California. I’ll be going back to the Centre for Quantum Technology next summer, and summers after that, too. But life feels different now: a 2-year period of no teaching allowed me to change my research direction, but now it’s time to teach people what I’ve learned!

It also happens to be a time when the Azimuth Project is about to do a lot of interesting things. So, let me tell you some news!

Programming with Petri nets

The Azimuth Project has a bunch of new members, who are bringing with them new expertise and lots of energy. One of them is David Tanzer, who was an undergraduate math major at U. Penn, and got a Ph.D. in computer science at NYU. Now he’s a software developer, and he lives in Brooklyn, New York.

He writes:

My areas of interest include:

• Queryable encyclopedias

• Machine representation of scientific theories

• Machine representation of conflicts between contending theories

• Social and technical structures to support group problem-solving activities

• Balkan music, Afro-Latin rhythms, and jazz guitar

To me, the most meaningful applications of science are to the myriad of problems that beset the human race. So the Aziumuth Project is a good focal point for me.

And on Azimuth, he’s starting to write some articles on ‘programming with Petri nets’. We’ve talked about them a lot in the network theory series:

They’re a very general modelling tool in chemistry, biology and computer science, precisely the sort of tool we need for a deep understanding of the complex systems that keep our living planet going—though, let’s be perfectly clear about this, just one of many such tools, and one of the simplest. But as mathematical physicists, Jacob Biamonte and I have studied Petri nets in a highly theoretical way, somewhat neglecting the all-important problem of how you write programs that simulate Petri nets!

Such programs are commercially available, but it’s good to see how to write them yourself, and that’s what David Tanzer will tell us. He’ll use the language Python to write these programs in a nice modern object-oriented way. So, if you like coding, this is where the rubber meets the road.

I’m no expert on programming, but it seems the modularity of Python code nicely matches the modularity of Petri nets. This is something I’d like to get into more deeply someday, in my own effete theoretical way. I think the category-theoretic foundations of computer languages like Python are worth understanding, perhaps more interesting in fact than purely functional languages like Haskell, which are better understood. And I think they’ll turn out to be nicely related to the category-theoretic foundations of Petri nets and other networks I’m going to tell you about!

And I believe this will be important if we want to develop ‘ecotechnology’, where our machines and even our programming methodologies borrow ingenuity and wisdom from biological processes… and learn to blend with nature instead of fighting it.

Petri nets, systems biology, and beyond

Another new member of the Azimuth Project is Ken Webb. He has a BA in Cognitive Science from Carleton University in Ottawa, and an MSc in Evolutionary and Adaptive Systems from The University of Sussex in Brighton. Since then he’s worked for many years as a software developer and consultant, using many different languages and approaches.

He writes:

Things that I’m interested in include:

• networks of all types, hierarchical organization of network nodes, and practical applications

• climate change, and “saving the planet”

• programming code that anyone can run in their browser, and that anyone can edit and extend in their browser

• approaches to software development that allow independently-developed apps to work together

• the relationship between computer-science object-oriented (OO) concepts and math concepts

• how everything is connected

I’ve been paying attention to the Azimuth Project because it parallels my own interests, but with a more math focus (math is not one of my strong points). As learning exercises, I’ve reimplemented a few of the applications mentioned on Azimuth pages. Some of my online workbooks (blog-like entries that are my way of taking active notes) were based on content at the Azimuth Project.

He’s started building a Petri net modeling and simulation tool called Xholon. It’s written in Java and can be run online using Java Web Start (JNLP). Using this tool you can completely specify Petri net models using XML. You can see more details, and examples, on his Azimuth page. If I were smarter, or had more spare time, I would have already figured out how to include examples that actually run in an interactive way in blog articles here! But more on that later.

Soon I hope Ken will finish a blog entry in which he discusses how Petri nets fit into a bigger setup that can also describe ‘containers’, where molecules are held in ‘membranes’ and these membranes can allow chosen molecules through, and also split or merge—more like biology than inorganic chemistry. His outline is very ambitious:

This tutorial works through one simple example to demonstrate the commonality/continuity between a large number of different ways that people use to understand the structure and behavior of the world around us. These include chemical reaction networks, Petri nets, differential equations, agent-based modeling, mind maps, membrane computing, Unified Modeling Language, Systems Biology Markup Language, and Systems Biology Graphical Notation. The intended audience includes scientists, engineers, programmers, and other technically literate nonexperts. No math knowledge is required.

The Azimuth Server

With help from Glyn Adgie and Allan Erskine, Jim Stuttard has been setting up a server for Azimuth. All these folks are programmers, and Jim Stuttard, in particular, was a systems consultant and software applications programmer in C, C++ and Java until 2001. But he’s really interested in formal methods, and now he programs in Haskell.

I won’t say anything about the Azimuth server, since I’ll get it wrong, it’s not quite ready yet, and Jim wisely prefers to get it working a bit more before he talks about it. But you can get a feeling for what’s coming by going here.

How to find out more

You can follow what we’re doing by visiting the Azimuth Forum. Most of our conversations there are open to the world, but some can only be seen if you become a member. This is easy to do, except for one little thing.

Nobody, nobody , seems capable of reading the directions where I say, in boldface for easy visibility:

Use your whole real name as username. Spaces and capital letters are good. So, for example, a username like ‘Tim van Beek’ is good, ‘timvanbeek’ not so good, and ‘Tim’ or ‘tvb’ won’t be allowed.

The main point is that we want people involved with the Azimuth Project to have clear identities. The second, more minor point is that our software is not braindead, so you can choose a username that’s your actual name, like

Tim van Beek

instead of having to choose something silly like




But never mind me: I’m just a crotchety old curmudgeon. Come join the fun and help us save the planet by developing software that explains climate science, biology, and ecology—and, just maybe, speeds up the development of green mathematics and ecotechnology!

5 Responses to Azimuth News (Part 2)

  1. Mike Stay says:

    It’s because many of us are crotchety old curmudgeons that we end up using names like “mikestay”, because so many of the old systems forbade spaces and were case-insensitive.

    • davidtweed says:

      Not just old systems: for good or ill, most command line frameworks (eg, unix-style shell prompts, database query languages, etc) default to using spaces as “different thing separators”. There are ways round it (using quotes) but then you sometimes need to quote for other reasons so you’ve got nested quotes to keep straight, … Likewise, things like search engines often decide they can ignore quotes and break at spaces despite what the user specifies, so searching for mikestay I’ll only get that string, whereas for “Mike Stay” the algorithms apparently believe I might actually be interested in a page with “stay here, Mike” on it…

      So you can pick up a pattern of avoiding using spaces if they’re only for aesthetics. This isn’t a good reason for choosing web-account names, but it is a reason.

      • Yeah. The darn spaces. And the darn dumb search engines. That’s why I am Florifulgurator (a unique google search term) on the wider web. My real name, Martin Gisser, exists at least twice on this planet. Luckily I’m not named Ludwig Huber, of which here in Bavaria alone there are hundreds.

        But John sees it right. The Azimuth Project is a (the!) serious c21st internet academy, where we should meet as real persons.

  2. One inspiration for combining software programming and Petri Nets comes from the original work of C.A.R. Hoare on Communicating Sequential Processes and from Dijkstra’s Semaphore Primitives.

    This culminated in one of the first models of CSP which was incorporated in a programming language as the rendezvous construct of Ada.

    With Ada, one can take any deterministic Petri Net and with very little effort, write the semantics directly as rendezvous behavior between tasks. A concurrent task or thread model is necessary as the foundation to any Petri Net implementation. Since tasks are built into the language, along with a built-in synchronization mechanism, that’s why Ada works as a good model. Say what you want about the language, but this was a case of some computer scientists who actually wanted to see if they could directly implement some theoretical concepts into a mainstream language.

    BTW, in the Unified Modeling Language (UML), Petri Nets are often referred to as Activity Diagrams. These are the brainchild of Grady Booch, who started off as an Ada guru, and spun those off from Booch Diagrams.

    I guess my point is that there is a rich history on working Petri Nets into software programming paradigms. Occam is also an early concurrency model, which may have predated Ada.

    The other point of entry is to study the history behind languages with co-routines and threads. Lots of these have library support and it wasn’t directly built into the language.

    Also consider languages with guarded Horn clauses such as have been implemented with concurrent versions of Prolog or with the Actor model.
    A horn clause is basically a trigger for firing a Petri Net transaction.

    I am personally doing lots with Prolog these days, which is a good match for the Semantic Web.

  3. arch1 says:

    Thanks for the intro to some of your new collaborators. I too hope that Ken completes his new blog entry soon, as the teaser sounds fascinating.

    It would also be very interesting to hear from David on machine representations of scientific theories and their conflicts. It seems pretty clear that Special Relativity, for example, could have emerged considerably sooner had there been available a way to more systematically identify and examine assumptions, alternatives and consequences. What’s less clear to me is whether the same is true of current research into a) fundamental laws, b) emergent behavior.

You can use Markdown or HTML in your comments. You can also use LaTeX, like this: $latex E = m c^2 $. The word 'latex' comes right after the first dollar sign, with a space after it.

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.