Theme
What is Jupiter
Jupiter is a tool designed to answer questions about systems before building them — or before changing them.
Questions it answers
- How long will a request or customer take from start to finish?
- How many servers or workers do I need to handle double the demand?
- Where is the system bottleneck?
- If I double the capacity of a specific stage, how much will the response time improve?
- How often does the system reach full capacity and reject work?
These questions arise across customer service queues, manufacturing lines, software architecture, microservices, sensor networks, and logistics — anywhere work arrives, passes through stages, and departs.
Why a simple average calculation is not enough
It might seem that a spreadsheet formula is sufficient. If service takes 5 minutes on average and a customer arrives every 10 minutes, the worker is busy half the time and nobody waits. Right?
Wrong. In real-world systems, queues form: arrivals are not evenly spaced. Sometimes two customers arrive close together, and the second one waits even when the worker has plenty of idle time on average.
And the impact is severely non-linear:
| Service time | Worker busy | Average customer wait |
|---|---|---|
| 5 min | 50% | 10 min |
| 9 min | 90% | 89 min |
The service time increased from 5 to 9 minutes (not quite doubled). Yet the customer wait multiplied by almost nine. No simple average calculation can predict this behavior.
What Jupiter adds
Jupiter takes into account that durations vary. Arrivals occur randomly, and service times do not take the exact same amount of time. It is from this variability that queues are born — and it is precisely this variability that simple averages overlook.
How a model works
You describe the system using the formalism of Stochastic Petri Nets:
- Places (circles): represent where things reside (a queue, a processing stage, available slots, idle resources).
- Transitions (rectangles): represent events and actions (a customer arrives, processing begins, a stage completes).
- Arcs (arrows): connect places to transitions and dictate the flow of tokens.
Inside places reside tokens, which represent the items moving through the system — customers, requests, packets, jobs — or available shared resources (idle workers, buffer slots). Transitions consume tokens from input places and produce tokens in output places.
"Stochastic" means that time delays follow probability distributions (such as exponential or normal distributions) rather than being rigid constants, closely matching real-world variability.
How to use Jupiter
- Draw the system using places, transitions, and arcs.
- Define delays and probability distributions for each stage.
- Declare what to measure using performance metrics (throughput, response time, utilization, blocking probability).
- Execute the simulation (stationary or transient) and inspect results with statistical confidence intervals.
- Compare scenarios by sweeping parameters automatically to identify optimal sizing.
What it is not
- It is not a programmable event simulator. You specify the system using Petri net formalisms without writing procedural code.
- It does not invent the model on its own. Jupiter calculates the mathematical consequences of what you drew. If the diagram does not reflect reality, the numbers will not either.
- It does not replace empirical measurement. It allows you to explore scenarios that you cannot yet measure in production: double the traffic, extra servers, or architecture refactorings.
Next steps
Proceed to Installation and Execution to set up and launch Jupiter on your machine.