By: Frederik Banning

Re-posted from: https://forem.julialang.org/fbanning/dummy-agent-based-modelling-in-julia-pla

Designing an agent-based model is never easy. Especially in the beginning when you have the rough ideas for the model in your head, maybe sketched some of the core behavioural rules, and gathered the references for them in an unordered list. You will advance through the regular steps of deciding on a model purpose, formulating precise research questions, properly formalising your model’s inner workings, maybe putting its core functions in mathematical notation or possibly even pseudo-code, …

At some point, however, you will find yourself starting up your IDE of choice (some do this step rather sooner than later) and stare at the blank file before you. You may smile out of anticipation of the grand things to come, the epiphanies that will strike you out of nowhere to make your code readable, easy to navigate, and performant at the same time. Or you may already release a deep sigh at the thought of endless iterations over your algorithms to get them to do what you intend them to do, or you might start to feel discouraged after a short while because of the lack of good documentation for things that feel like core features to you. You don’t know where to start and what to do next, how to structure your code so that it stays maintainable in the long run, who to ask for help if you encounter a road block on your journey, and so on and so forth.

If you nodded at least once or twice while reading the paragraphs above, this little series might be for you. My name is Fred and I’m currently a PhD student at the Chair of Macroeconomics at Ruhr-University Bochum in Germany. In my free time I do volunteer work for the German Red Cross and I’m also a co-host of the Mikroökonomen podcast (in German). I neither have a background in computer science, nor am I outstandingly knowledgeable in the area of agent-based modelling (besides it being my day job). But over time I’ve picked up more and more how to code in Julia and how its community works. And due to how approachable both the language and its community are, I’ve ended up contributing to some Julia packages (most notably Agents.jl and InteractiveDynamics.jl and recently even started an own package (OSMMakie.jl) as a side project.

I’ve started my ventures into the field of ABMs a few years ago during a course of my master’s programme. We learned about behavioural rules of economic agents, some algorithmic thinking, and how to code in NetLogo and I had a lot of fun working with it. Over the past years, I’ve even had the opportunity to assist in teaching the practical sides of agent-based modelling with NetLogo and how students can use it to tackle their own research questions. Ever since my first contact with ABMs, I’ve got hooked on the concepts of Computational Economics to explore and hopefully better understand the underlying complex relationships in the economic parts of societies.

Even though I’ve initially learned and later taught agent-based modelling via the great tool that is NetLogo, I’ve relatively quickly came to realise that its great prototyping abilities, easy to learn and use syntax, and built-in visualisations come with some trade-offs. Two of which still stand out the most to me:

1. For one, it’s relatively slow compared to other ABM frameworks and, to be quite frank, there’s not much that we as regular users can do about this. Have a look here for one attempt to quantify the differences between popular frameworks. As can be seen from this, Julia is well suited for executing highly computationally intensive ABMs. After all, agent-based models are at their core not really much more than repetitive number crunching under a set of given rules. And that, by chance, is a domain in which Julia really shines.

2. Users also need at least a second tool or programming language to analyse the data generated by their ABMs and plot it in a visually appealing way (preferably even in a publishable form). Julia solves this issue both by design and through its rich package ecosystem which allows agent-based modellers to code continuous pipelines from the model itself into data wrangling and finally visualisation. No need for intermediate data conversion and, maybe more importantly, no need to learn multiple syntaxes.

It’s this kind of uniform approach utilising just a single programming language for all your needs, that can allow researchers to free up some precious mental capacities and gain speed in writing clear and concise code. All while allowing others to reproduce your findings and modify or extend your models. Taking these two points together, I firmly believe that Julia is indeed a great candidate for writing agent-based models.

A quick side note: Agent-based modelling has a broad community ranging from disciplines such as physics and biology to social sciences and economics. Due to my personal background, this series will naturally approach the topic of ABMs from this perspective as well. This means that in the examples I choose, the agents are more likely to represent humans, firms, or some other kind of institutions more often than for example cells, particles, or other animals. Let this not distract you from the fact, that ABMs can be used for a multitude of great applications and scenarios from various scientific backgrounds. At its core, the technicalities stay the same – it’s just the story and the subjects that change.

For now, this is just a dummy post to test this new platform in the broader Julia community (yet, already having spent a non-negligible amount of time on this post). And while I’m planning to contribute a few more posts to this series, it’s as of yet unclear how long this will last. Somehow it’s an attempt to give something back to the Julia community besides answering questions on Discourse, Zulip, Slack and Github. Hopefully it will succeed in conveying my enthusiasm for doing agent-based modelling in Julia and convince others to try it out for themselves. It’s not particularly harder to code good ABMs in Julia than it is in any other framework like NetLogo or Mesa. But it might take some time to get used to the “Julia way” when coming from another language. This is what I’m trying to help with. Maybe you’ll like it, maybe you won’t. In the end, I would be glad to hear about your experiences, no matter if they’re positive or negative.

Designing an agent-based model is never easy.
So let’s not make the coding part any harder than it has to be.

So long,
Fred