Update quickstart section and reformat files

Author: oezden

.gitignore

@@ -1,5 +1,7 @@
 .idea/
 .bundle/
+.devcontainer/
+.vscode/
 _site/
 _includes/
 vendor/

LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2022, Technical University of Darmstadt, Darmstadt, Germany
+Copyright (c) 2026, Technical University of Darmstadt, Darmstadt, Germany
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

_config.yml

@@ -23,10 +23,10 @@ callouts:
     color: red
 
 mermaid:
-  version: "10.3.0"
+  version: "11.12.3"
 
 aux_links:
   "ElastiSim on GitHub":
     - "//github.com/elastisim"
 
-footer_content: "Copyright © 2023, Technical University of Darmstadt."
+footer_content: "Copyright © 2026, Technical University of Darmstadt."

acknowledgement.md acknowledgment.mdacknowledgement.md renamed to acknowledgment.md

@@ -1,10 +1,10 @@
 ---
 layout: default
-title: Acknowledgement
+title: Acknowledgment
 nav_order: 8
 ---
 
-# Acknowledgement
+# Acknowledgment
 
 If you have used ElastiSim in your research or publication, please cite the original paper.
 
@@ -31,4 +31,4 @@ If you have used ElastiSim in your research or publication, please cite the orig
 
 ### Citation (ACM style)
 
-Taylan Özden, Tim Beringer, Arya Mazaheri, Hamid Mohammadi Fard, and Felix Wolf. 2022. ElastiSim: A Batch-System Simulator for Malleable Workloads. In *Proceedings of the 51st International Conference on Parallel Processing (ICPP '22)*. Association for Computing Machinery, New York, NY, USA, Article 40, 1–11. [https://doi.org/10.1145/3545008.3545046](https://doi.org/10.1145/3545008.3545046)
+Taylan Özden, Tim Beringer, Arya Mazaheri, Hamid Mohammadi Fard, and Felix Wolf. 2022. ElastiSim: A Batch-System Simulator for Malleable Workloads. In _Proceedings of the 51st International Conference on Parallel Processing (ICPP '22)_. Association for Computing Machinery, New York, NY, USA, Article 40, 1–11. [https://doi.org/10.1145/3545008.3545046](https://doi.org/10.1145/3545008.3545046)

configuration.md

@@ -8,4 +8,4 @@ nav_order: 9
 
 The easiest way to contact us is via our Slack workspace. Please use the invitation link below to join our Slack workspace.
 
-[ElastiSim Slack](https://join.slack.com/t/elastisim/shared_invite/zt-23ln6g4dc-DZwf0b1TV~qgjVkPKQGI4A){: .btn }
+[ElastiSim Slack](https://join.slack.com/t/elastisim/shared_invite/zt-23ln6g4dc-DZwf0b1TV~qgjVkPKQGI4A){: .btn }

contact-us.md

@@ -10,13 +10,15 @@ nav_order: 2
 ## Required libraries
 
 ElastiSim requires four libraries to be installed (or available):
+
 - [SimGrid](https://simgrid.org/) to simulate the underlying platform
 - [ZeroMQ](https://zeromq.org/) for C++ ([cppzmq](https://github.com/zeromq/cppzmq) binding) to communicate with the scheduler process
 - [JSON for Modern C++](https://json.nlohmann.me/) to read input files and wrap messages (provided with ElastiSim)
 - [ExprTk](https://www.partow.net/programming/exprtk/) to evaluate performance models (provided with ElastiSim)
 - [Activity Indicators for Modern C++](https://github.com/p-ranav/indicators) to indicate the progress of processed jobs (provided with ElastiSim)
 
 Depending on the scheduling interface, an additional ZeroMQ binding is required. ElastiSim currently supports a Python interface to write scheduling algorithms and therefore requires:
+
 - [PyZMQ](https://pyzmq.readthedocs.io/) to communicate with the simulator process
 
 ## Build (on Linux systems)

get-started/installation.md

@@ -7,44 +7,21 @@ nav_order: 1
 
 # Quickstart
 
-The easiest way to get started with ElastiSim is by cloning the example project available on [GitHub](https://github.com/elastisim/example-project). This scenario simulates an FCFS (first come, first serve) scheduling algorithm applied on 500 jobs—including all job types—with alternating compute and I/O phases (see [Application model](#application-model)) running on a crossbar topology with 128 compute nodes. While evolving and adaptive jobs request a new configuration at the beginning of each iteration of the specified phase, malleable jobs accept any reconfiguration. The scheduler accepts all evolving requests that shrink the job but accepts evolving requests to expand the job only to a maximum of available nodes. For malleable jobs, the scheduler expands to the highest possible number of nodes based on the number of available nodes. The following steps will create a Docker container including all the required libraries for ElastiSim and start the simulation.
+The easiest way to get started with ElastiSim is to use the [Dev Containers](https://github.com/elastisim/elastisim-devcontainer) we provide on GitHub. Dev Containers are containerized development environments native to VSCode. We provide all necessary setup files that automatically install required libraries and dependencies within a Docker container, facilitating rapid development. To learn more about Dev Containers, please visit the official [Dev Container documentation](https://code.visualstudio.com/docs/devcontainers/containers).
 
-## Installation
-
-To build the container required to run ElastiSim, install Docker and execute the following command:
-```sh
-docker build -t elastisim .
-```
+We provide two flavors of Dev Containers for 1) users and 2) contributors. The user Dev Container builds the environment for developing custom scheduling algorithms using the ElastiSim simulation engine and the Python interface. After the setup, the container automatically clones the [example project](https://github.com/elastisim/example-project), enabling users to experiment immediately. In contrast, the contributor Dev Container targets developers contributing to the ElastiSim project and additionally includes the source code for both projects, the [simulation engine](https://github.com/elastisim/elastisim), and the [Python interface](https://github.com/elastisim/elastisim-python). Both Dev Containers provide all necessary settings, launch, and build files to run the experiment or compile the project immediately. If you use ElastiSim to develop and evaluate custom schedulers, we strongly advise using the user container, as it focuses on a minimal build and performance.
 
-## Simulation
-
-To run the simulation, execute the following commands in two different sessions:
+The scenario in the example project simulates an FCFS (first-come, first-serve) scheduling algorithm applied to 500 jobs—including all job types—with alternating compute and I/O phases (see [Application model](#application-model)) running on a crossbar topology with 128 compute nodes. While evolving and adaptive jobs request a new configuration at the beginning of each iteration of the specified phase, malleable jobs accept any reconfiguration. The scheduler accepts all evolving requests that shrink the job, but accepts evolving requests to expand the job only up to the maximum number of available nodes. For malleable jobs, the scheduler expands to the highest possible number of nodes based on the number of available nodes.
 
-### Linux:
-```sh
-docker run -v $PWD/data:/data -v $PWD/algorithm:/algorithm -u `id -u $USER` --name elastisim -it --rm elastisim /data/input/configuration.json --log=root.thresh:warning
-docker exec -u `id -u $USER` -it elastisim python3 /algorithm/algorithm.py
-```
+## Installation
 
-### Mac OS:
-```sh
-docker run -v $PWD/data:/data -v $PWD/algorithm:/algorithm --name elastisim -it --rm elastisim /data/input/configuration.json --log=root.thresh:warning
-docker exec -it elastisim python3 /algorithm/algorithm.py
-```
+To build the Dev Container, clone [elastisim-devcontainer](https://github.com/elastisim/elastisim-devcontainer) and open the folder in VSCode, where you will see a notification that the repository contains Dev Container files. Open the repository in the container and choose _ElastiSim User_ or _Contributor_, respectively. The container will now build automatically and set up all necessary files.
 
-### Windows (PowerShell):
-```sh
-docker run -v ${PWD}\data:/data -v ${PWD}\algorithm:/algorithm --name elastisim -it --rm elastisim /data/input/configuration.json --log=root.thresh:warning
-docker exec -it elastisim python3 /algorithm/algorithm.py
-```
-
-The first command runs the ElastiSim simulator process and accepts two inputs:
-- the configuration file (JSON)
-- the logging level
+## Simulation
 
-For a more detailed output, change `--log=root.thresh:warning` to `--log=root.thresh:info` (caution: verbose).
+To run the simulation, execute the _Run ElastiSim Scenario_ from the _Run and Debug_ panel. If you are using the contributor Dev Container, you must build the project first using the CMake configuration files provided by the container.
 
-The second command runs the scheduling algorithm.
+For a more detailed output, change the arguments of the simulation engine from `--log=root.thresh:warning` to `--log=root.thresh:info` in the launch.json file under the .vscode folder (caution: verbose).
 
 # Application model
 

get-started/quickstart.md

@@ -7,10 +7,10 @@ nav_order: 3
 
 # Scheduling protocol
 
-During simulations, the simulator and the scheduler process are in constant communication. The scheduling protocol defines *which* data the processes exchange *when*.
+During simulations, the simulator and the scheduler process are in constant communication. The scheduling protocol defines _which_ data the processes exchange _when_.
 
 {: .note }
-Do not confuse the scheduling protocol with the communication protocol. The scheduling protocol does **not** define *how* the data is exchanged.
+Do not confuse the scheduling protocol with the communication protocol. The scheduling protocol does **not** define _how_ the data is exchanged.
 
 ElastiSim invokes the scheduling algorithm periodically in a user-defined interval or at events such as job submissions or scheduling points (see [Configuration](/configuration) for all options). Each invocation contains a list of compute nodes, jobs, and a map holding system information. After the scheduling algorithm makes a scheduling decision, the scheduler process forwards the decision to the simulator process, applying the new schedule.
 

get-started/scheduling-protocol.md

@@ -7,6 +7,7 @@ nav_order: 1
 # ElastiSim
 
 Resource and job management systems (often called batch systems, job schedulers, or workload managers) schedule jobs and provide resources in large-scale computing environments. ElastiSim is a batch-system simulator for malleable and evolving workloads, including the simulation of
+
 - jobs and applications,
 - the scheduling algorithm, and
 - the platform (powered by [SimGrid](https://simgrid.org/)).