So, good morning everyone. I am Adrian, a PhD candidate from Lidon University in the
Netherlands and I'm going to, today I'm going to talk about my project, my software, so
called relativization, which is a weird thing, an interstellar social simulation framework
and a turn-based strategy game as well. And I hope this can be an interesting start of
today's schedule. So, before I go into the details of my thingy, I would like to do a bit of self
introduction because it relates to my overall open source development experience. And I was
educated in physics, I did my bachelor in physics, I did some master's research on so-called
gravitational waves under the LIGO collaboration. And I must say, like before my master's research,
I would say, kind of mathematical students, I didn't really like computer, I like pen and paper
more. And, but like my research forced me to appreciate computer because I was forced to use
doing things like supercomputers, Linux, terminals, and writing programming language, programming
like C or Python. So, I started to appreciate like software or open source software in general. So,
that's why I get into this world. And after my master, I decided to kind of switch my field to
do something social science. So, that's why I came to the University to do something called like
quantitative science study. And I'm supposed to work on, supposed to work on social modeling,
simulation, or data analysis on some kind of social data, actually most specifically for
academic system. And as a hobby, I kept contributing to open source software because I think it's
fun to work on, I mean, just use the software and if you find something wrong, then you just submit
a PR or a great issue for that. And I learned a lot from that kind of process. And then like,
after, because I started my PhD right before the pandemic, as you can imagine like things go
when quite long, because I partially blame the pandemic, because for example like the data that I'm
supposed to use is still not ready, even now. And the whole collaboration become mass, the
infrastructure is mass. So, I partially also blame the engineer in my collaboration because
they are so annoying to work with. So, I have to rescue my PhD, right? I can't wait for that,
the things to happen. So, I need something to work it out. I can work it out by myself. And
because I, because it's pandemic, so I have to work from home. And I was also kind of traumatized
by the collaboration that I experienced. And I know something about physics because of a
background. I know something about social modeling. And I'm also kind of familiar with
software engineering. I'm not trained in that field, but I learned a lot from my hobby. So,
it is natural for me to try to combine these things together to create something for a thing,
a weird thing, interstellar simulation. And then like, perhaps some of you guys are a fan of
science fiction, movies, or games. And you may ask these kind of big questions like,
will human civilization become interstellar one day in the future? Or like, does alien exist or
not? And if they exist, or if we will become interstellar, we will be curious about like, what
is the form of society of those interstellar civilization, right? And of course, it's very
hard to study those kind of thing, rigorously, in academic settings. But perhaps one way,
at least I claim, I argue that one way to try to explore this is to assume that some social
theory we know nowadays can still be a good approximation for that kind of society, like
perhaps if we expect that they to also be utility seeking, or there are some collective
actions there. And of course, we can study that rigorously because we don't have the data,
we don't have observations, but we can try to explore this kind of domain by simulation.
And in case if you're not familiar with social modeling, or like,
in case if you're not familiar with social modeling, and nowadays when we talk about social simulation,
it's majority, like they're talking about agent based modeling. So, social scientists design
some behavior rules based on the understanding of how human works, or based on some experiments to
design computational rules for agents, and they put the agents into a world just like
machine learning people do, and to see how to interact with each other and interpret the
overall simulation outcome from that. And there are many existing frameworks that can help us
to do this kind of simulation, but I have to create my own framework because for existing
social simulation framework, they don't support the physics well, because we're going to work
on like interstellar society, and it is a scale that is not on the earth, so it's not easy to
deal with, it's possible, but it's not trivial. And there are also some kind of physics simulation
framework out there as well, but they are not built for social scientists, so it's also a bit
hard to work with. So that's why I have to create my own framework. I think it's interesting and
useful if I want to create something meaningful for this thing. And when I talk about the physics
for interstellar society, I'm talking about special relativity, which is simple undergraduate
level physics, because it is a fiction when we consider a scale like 100 light years or 10
light years, I think it's a good starting point of like try to imagine about this kind of thing.
And special relativity tells us that there's an intrinsic time delay out there, so everything
cannot travel faster than the speed of light, and also special relativity tells us that like
there's a time direction effect, so if you move very fast, close to the speed of light,
you're close to the store, so experience the store time essentially. And in the setting of
social simulation, we have to deal with problems like what can you see or what can an agent see,
and how an agent interacts with other agents, because of time delay, and how we change the
state of the agent. I will go into this one by one in the following slides. Because of the time
delay, information travels at the speed of light, so we are not seeing each other instantaneously.
We are seeing the path of each other because of the delay, so here the red agent, the red people
here see the, the red person here see the, the, the path of the blue, blue agents of people,
because they have, they have time delay, and it depends on the distance. And technically they
see the, the path like comb of the, of the, of the universe at that point. And how the second problem
is how the, how the agents interact with each other. I mean if you're a programmer, you're
probably familiar with the command design pattern, and this is used for like dealing with, if you
have something you might execute, but if you have, if you have a delay, then you have to create a
command, wait for a delay, and send it to, send it to a target, and this is what I, I, I, I used it in, in, in, in this framework,
so that like if you have some, some, some agent need to interact with each other, they can't, they can't
just do that directly, they have to, have to send the command and, and the, the command travels at a speed of light in, in, in the
universe. And lastly, the, the, the last problem, how, how we change the state of the agent. We define
a term here called mechanism, which is essentially the dynamics of the model. It, it, it changed the state of the
agents and, and send commands out, so you define the whole, how, how, how the model actually works scientifically. And
recall that because clock takes over for, for, for, for moving agents, so I divide this into, into two types of
mechanism, a regular mechanism executed one, a process once per turn, and dilated mechanism process once per end turn
because it depends, and, and, and the end depends on the speed, because if it is moving faster, then some things, it's
slower, time is slower there, so executed, the execution is slower there. So it is, for, for, for convenience, if you, if you
model your thing space, and if you, if you, if you model your thing space on these two, two types of mechanism, then it's
easier to, to, to, to adjust, to, to follow the physics. And as an example, regular mechanism could be something like
you observe things, and update your information, and it's not something that you, it actually takes time so it can, it can
be executed once, once per turn. And for dilated mechanism, it can be something like manufacturing, it actually takes
time to, to, to produce some product, and to, to, to, to make, make it and send it out. So if you have a slower time, then
you, you manufacture that, sorry. So to deal with this, this kind of problems, I, as I said, I created framework, and the
framework is written in Kotlin, there are many reasons behind that, I'm not going to, to, to give you that, and, and
basically the framework and force a specific way to, to, to, to model your, your, your, your social model, so that it, it can
be automatically, automatically account for the physics. And it also provides some functionalities to, to, to help you to
develop the so-called in this data social model. And it deal with some technical subtleties like parallelization of the, of
the, of the simulation, and how do you serialize things into, into, into data, or like how do you make deterministic
simulation using, under a parallel process. And this is the, the kind of the core of the, of the framework. And you can
check my archive repeat, and actually it's going to be a proceeding for, for some other conference. And, and for the, for the
algorithmic details, and for the mathematics details. You want to take a picture? I, I, you can find it like in, in the
last slide, but anyway. So, I mean, I, I, I didn't begin, I, I wasn't an experienced programmer when I started this
project, so I, I make some decision that perhaps I would change if I, if I do it in another way. If, if I start it, start
from now. But like, I, I, I, anyway, like I make some decision, for example, here on, on how, how we should use this
framework, for example, I decided that like this should be used, say, I say, I say, I say, okay, here it works. So, there
I have some technical reason behind why I made this decision because I think it's always easier to provide a library for people to use.
I mean, because the reason behind it is that I try to keep it in a pure Kotlin project and it's quite not possible to do things like this,
serializing string into objects because the diffraction library of Kotlin is not very powerful.
And anyway, this is the decision I made. I may change in the future, but it's how it's now working.
And to use this, you have to create a template using the source code and build a model based on the template.
And I have created a few effect samples on how to use this framework.
I mean, I will do a brief illustration on the results because it's very interesting to see how things actually work out.
So the first example is the flocking model, which is kind of the standard of the 101 HMAS modeling.
It's a very simple model. The bird follows a very simple alignment bruise and they align with each other.
And it creates some interesting microscopic pattern as shown in the figure.
And here we are interested in interstellar flocks.
I mean, it's a very hypothetical scenario, but you can interpret it as kind of a group of spaceships
and they try to align with each other in the universe where some kind of mysterious creature like living in space.
And I assume for the sake of physical realism, I assume they are propelled by a proton rocket
and we can measure how well the flocks align.
And this is the simulation result. I'm also not going into the details of this thing.
But you can see some interesting things like if you can adjust the speed of light because this is a simulation
and if the speed of light is stored and they take more time, it takes longer to communicate
and they are less well-ordered and you can also tune the perturbation on the flock
and so it takes more, it's harder to align with each other and it takes more energy to do so.
And you can see in the figure on the left hand side or in the right hand side in your alignment
then it takes half the mass of the population to align with each other for one year, for one turn.
So it's not a very environmentally friendly way of traveling, I would say.
And the second example is some kind of knowledge dynamics which is closer to what I'm supposed to do in my PhD.
So we study how I try to model how research or knowledge is generated in the interstellar setting
and there are some assumptions that are made like cooperation takes time,
we need cooperation to stimulate innovation but cooperation takes time to process.
You have to invite people to cooperate with you and you have to wait for the response
and if it is very far away then it takes a long time to work with people.
So this thing is affected by the time delay.
And there are some other factors like if there is a small time delay
and so you have a more rapid information exchange then it essentially creates a more competitive environment
because when I do something and you want to compete with me and you update information very frequently
then it creates a kind of stress to work your research out.
And also like research of the next time, it is a dilated mechanism.
It is affected by the time dilation if you want to move.
There is a cause if you want to move closer to each other to do research
like there is a cause if you want to move from your home country to this place to work with each other.
So this is also some kind of simulation results.
This I would say is kind of interesting.
So we can also tune the speed of light and as you see in the figure on the left-hand side
the blue curve was lower at the beginning and it becomes higher eventually.
This is a curve when you have a very slow information travel.
Because the innovation or the cooperation started very slowly at the very beginning
so it rises very slowly but at the finals ultimately because of its less competitive
overall research outcome becomes better eventually.
I think it is an interesting result.
The figure on the right-hand side shows that there are two kinds of strategies.
You can stay in your home country and do all the things remotely
or you can move the conference physically to work with each other.
The orange curve represents the moving strategy
and the blue curve represents the remote strategy.
There is a cause imposed by the city because there is time dilation
so it starts out lower and eventually pays off in the future.
I think it is an interesting result to show up here.
This is kind of interesting but you can also always criticize about this kind of model
because it is too hypothetical. We are studying something that is not happening in the real world
and perhaps we are getting nothing out of that.
I kind of agree with this criticism but I am just trying to get something out of the framework.
If people are not interested in this kind of model
or I also feel like this is not interesting enough
and then I made the decision that perhaps I can make a game out of this to make it more interesting.
The reason why I decided to make a game is also because I like simulation games
and simulation games are kind of similar to modeling
or HMAS modeling in a sense.
Also, I have many things that I want to test out. The model that I have presented are kind of simple models
but they are more complicated mechanisms that you can implement
but you can't do this rigorously because they are so complex
you can't get anything adequate or interpretable from those ideas.
A game provides an environment for me to test things out
and to just explore what I can do in this institutional model.
Also, perhaps this is one of the sensible ways to get something actually useful from the framework.
If it is not very academically interesting, at least I have a game for that.
For a game, it can be very complex and I try to address many different things in the game
and I try to ask a very good question.
For example, we can try to ask how should the economy look like in the international society?
Does credit-based economy work?
Nowadays, we are relying on currency, credit card
but those kinds of currency relies on some fundamental building blocks of the society
which might not work in an interstellar setting because the time delay, how do you exchange money
and how do you define the exchange rate?
Perhaps a simple part of the economy that we use historically is a better choice for those kinds of society here
and perhaps we can use some kind of fuel or energy as the money instead of credit card.
Also, we can ask how the political system works.
Does democracy work there?
If you have to wait for 100 years to receive the full-time results from the other planet.
We can also ask how we can optimize scientific research in this kind of system.
I have my own ideas on how these things work.
I put all the things into the game including population dynamics, politics, diplomacy, economics
like warfare, science and technology. Some of them are typical elements in strategy games
and some of them are not that typical but I still get the inspiration from some other games.
I try to get this to work on PC and Android
and that's one of the reasons why I choose Collin to implement this kind of thing
and I hope this is going to be a multi-player game in the future.
I implemented some kind of server-kind architecture.
For a game, you have to limit how a client can act
because you can't allow them to do everything that they are going to cheat in the game.
What they can do is essentially receive a few of the universe
and they can send a command to do action.
I also created a utility-based or DO utility-based AI for the game.
This is the Baker architecture that is built on top of the framework.
This is the screenshot of the game.
I know this is not graphically very attractive but this is like,
oh, I can do and... where is it?
I'm losing my side.
This is how the game actually looks like.
You can do some things here to do something and add some commands.
This is a complex interface and so I'm not going to actually show everything here
but as something is working here.
What's the scale?
The spatial scale.
For this, it's like three times three light years keep.
This is a very small universe.
It can be larger.
At least it can handle a thousand light-year keep game without pressing my computer.
Thanks for the open-source ecosystem.
I can rely on all kinds of open-source library to build my game.
I use DeepGDX for the working interface, I use Coroutine for the parallelization,
and also thanks for the open-art community so that because I'm not an artist,
I can't create all the art by myself.
I can rely on creating component-licensed assets and I can use open-source software
to escape if I want to draw something.
It's going to be the end of my presentation but I'd like to have a bit of reflection on my project.
I think I've learned a lot by contributing to open-source software
and the ecosystem gave me plenty of building blocks from my own project.
Of course, because of this, it's natural for me to also open-source my project
and at least I've created something interesting.
There are also some problems that I face during the development of this project.
For example, there's a lack of open-source culture in my workplace.
Some people there do use open-source software but most of them do not care that much.
Most of the time, I'm by myself.
As a one-man project, it's a bit too ambitious, I would say.
I don't have time to publish all the things like graphic interface documentation
and I can't ensure that things are fun to play and I don't have time to work on the translation.
I did try but I don't have time to work on all kinds of things
because I'm also doing my PhD, I have to write papers and do presentations.
As I decided to go fully open-source, I chose those libraries to depend on
but perhaps there are some kind of industry standard solutions like
if you're creating a game, people just use Unity for that
and perhaps it would be better for the project so I have more time for other things.
It's just something that perhaps there's a price to pay for if you decide to go to go open-source.
Actually, I did try a bit to commission my process because it's possible to sell an open-source game, right?
I know it's possible but it's also very hard to do so.
It takes time to advertise it so I gave up eventually.
I didn't have time for an hour to push it forward.
This is the summary of my presentation.
I have created a framework for industrial and social models
and I have created some models based on the framework.
I have also created a game on top of that
and perhaps it's lacking some immediate practical value
and that's not what I thought was that like it didn't exist tomorrow, right?
But I think it's not going to happen in a short while.
So perhaps there's no immediate practical value but I still believe this kind of meaningful
and educational exploration.
If the game is fun to play eventually then you can ask your kids to play for that
and perhaps they can learn some physics from the game, right?
I don't know. And at the very least, at the most important,
unless I feel like I've achieved something in my PhD,
I'm not wasting my time in my pandemic.
So that's all my presentation and this is the link of the project
and if you'd like to make it a star, just check it out.
And the thing that I show is, I think you can find those things
in the readme file of this page.
So thanks a lot for your attention.
We'll take a few questions while the next speaker will come and...
Thank you.
Okay, Hafer.
In your simulations when you said that the simulations then cluster,
how many years was simulated in the simulation
before you got to sort of the result?
Yeah, I'm talking like...
Can you repeat the question for the recording?
So the question was like how many years did I simulate for the model that I presented here?
I typically simulate it for 1,000 or 2,000 years
and because of the spatial scale it's like 10 times 10 times 10 light year
so it has affection time for the spaceship
to move towards each other and to do the cluster.
I assume that they move at a speed of light velocity.
And you have a question?
Yes, I guess it's more technical.
So your framework is written in copper.
Does it support any form of extension like in another JVM image?
I mean, in principle you can use Kotlin with other JVM images.
In your, for instance, or I guess customized agents,
maybe even maybe the physics model that say
I want to implement faster than light and travel or something like that.
So the question was like can you use other JVM language to extend it?
I think in principle it is possible because you can always,
the way to use this is to create something from the source code
and you can always work with JVM language in the source code.
But I'm not entirely sure because I use some Kotlin feature like inline function
to simplify the code so I'm not sure for that kind of thing
can you use it nicely with other JVM language?
I know you didn't go into that, but why Kotlin?
Why not like Azure or Java?
I mean, because I want to work on, I want to actually work on Android
and you know, Android Java support is not great.
Okay, sure.
Thank you.