Skip to main content
Log in
S

Servuc

@Servuc·19 public vizzes

Loading thumbnail…

Teach Docker-compose - TP1

Three Docker Compose configurations compare ways to manage MySQL data persistence and service networking. The examples use the `version: '2'` Compose API, defining `mysql` and `phpmyadmin` services with environment variables for database credentials and container ports. The first binds a local directory (`./data/db`) as a volume, the second declares a named volume (`mysql-data`) and explicit networks (`mysql-network`), and the third maps a host path (`/data/on/host/dir`). Each file shows YAML structures for `services`, `networks`, and `volumes`, highlighting how Compose handles data lifecycle differences.

Nov 14, 2025
Loading thumbnail…

Teaching :)

This example demonstrates a progressive Arduino teaching sequence, showing how to move from basic LED blinking to reading an analog sensor and handling button interrupts. The code uses the Arduino `pinMode`, `digitalWrite`, `analogRead`, and `attachInterrupt` APIs, with each sketch building on the previous one. It also includes JavaScript code using the `serialport` library to read Arduino serial output and test the connection via `yarn add serialport`. The visualization highlights both the physical wiring changes (LED pin, sensor pin, switch pin) and the serial communication between the Arduino and a computer.

Sep 26, 2025
Loading thumbnail…

Gist a4fd8efdd4e30c3bb84fafb3e3802025

This visualization shows the setup process for running the Epson Printer Utility inside a Docker container with a graphical interface. It uses a Dockerfile to install Qt4, LSB, and CUPS libraries, then downloads and installs a specific `.deb` package for the printer utility. The container is launched with the `epson-printer-utility` command after starting the `ecbd` service, with X11 and CUPS socket mounts to enable display and printing functionality. The example demonstrates containerizing a GUI application with hardware access.

Feb 2, 2023
Loading thumbnail…

Gist d1078368f5abf1c151c087b778dfbdaf

This example shows a simple Arduino program that reads a digital input from pin 2 and mirrors its state to an LED on pin 13. The setup configures the LED as an output and the input pin, while the loop continuously samples the switch every 100 milliseconds and writes the corresponding HIGH or LOW value using `digitalWrite`. It demonstrates basic I/O control and debouncing-free state reading with the Arduino `pinMode` and `digitalRead` APIs.

Nov 20, 2020
Loading thumbnail…

Gist d6881ff1705f8c86cc3c3b09327ad069

This Arduino sketch demonstrates a color-fading light sequence across three LEDs using the `analogWrite` API with pulse-width modulation values from 0 to 255. The `loop` function cycles through pairwise transitions—red to green, then green to blue, then blue to red—with `lightMe` incrementally raising one channel’s brightness while lowering another over ten steps, pausing via `delay(250)` between adjustments. Each pair ends by setting one LED fully off and the other fully on, revealing a continuous, repeating crossfade effect.

Nov 20, 2020
Loading thumbnail…

Gist f575906ce727448e6f3d5f26a151ea55

This example visualizes the network topology defined in a Docker Compose file, showing how the nginx, php, and db services connect through the frontend and backend networks. It renders the service containers as nodes positioned by a force-directed layout from D3’s `d3.forceSimulation`, while edges represent network membership, with each container linked to its respective network based on the YAML configuration. The visualization reads the `docker-compose-network.yml` structure directly, using its service and network definitions to drive the graph’s data model.

Oct 1, 2020
Loading thumbnail…

docker-swarm

This example demonstrates a Docker Swarm deployment of a PHP application behind an Nginx load balancer, using a Compose file to define the service topology. The visualization shows the network layer with an overlay network bridging the webapp replicas and the manager-node proxy, while the Nginx configuration references an upstream cluster with multiple server IPs. The PHP container serves a simple script that echoes the container’s hostname and IP, illustrating dynamic scaling behavior. The code relies on Docker Compose’s `deploy` keys for replica counts, update parallelism, and placement constraints.

Oct 10, 2019
Loading thumbnail…

Example of docker-compose.yml

This example shows a minimal Docker Compose setup that declares two services for a web application. The `docker-compose.yml` file defines a `web` service built from the local directory, which publishes port 5000 to the host, and a `redis` service using the official `redis:alpine` image. The file relies on the Compose specification’s `version`, `services`, `build`, `ports`, and `image` keys, with a YAML structure that maps service names to their configuration. It demonstrates the core pattern of linking an application container to a backing data store without additional network or volume definitions, based on the example from Docker’s official getting-started documentation.

Aug 7, 2018
Loading thumbnail…

Example of continue integration to Docker Hub

This example shows a GitLab CI/CD pipeline configuration for automating Docker image builds and pushes. The `.gitlab-ci.yml` file defines a single `build` stage that uses the `docker:latest` image to execute the build and push steps. It sets a `CONTAINER_TAG` variable combining an image name with the CI build reference name, then uses Docker commands (`docker build` and `docker push`) to compile the image from the current directory and upload it to Docker Hub. The configuration leverages GitLab's CI environment variables and predefined `$CI_BUILD_REF_NAME` for tagging.

Aug 6, 2018
Loading thumbnail…

Gist for http://servuc.github.io/teaching/iot-4.html

This example demonstrates a mesh-network message-passing scheme for IoT nodes using the MySensors library and nRF24 radio modules. The Arduino sketch defines a single node (ID 10) that receives V_POSITION and V_LIGHT_LEVEL message types via the `receive()` callback, processes them, and can forward a path-end destination to adjacent nodes. It also sends a V_LIGHT_LEVEL acknowledgment to the gateway, with commented TODOs for gateway-driven light control and conditional forwarding logic. The setup and presentation routines blink an LED to signal initialization and radio handshake, while the main loop simply sleeps between transmissions.

Nov 9, 2017
Loading thumbnail…

Example of Dockerfile for teaching

This gallery example presents a collection of Dockerfile and docker-compose configuration snippets for teaching container orchestration. The Dockerfile.php.example demonstrates a multi-step build process using Debian as a base, installing PHP CLI, copying local scripts, downloading remote data, and configuring volumes, ports, and the working directory. The docker-compose files illustrate core Compose features including service definitions with MySQL and WordPress images, port mapping, environment variables, device access, links, and named volumes. The code directly shows YAML syntax for `services`, `volumes`, and specific directives like `build.context`, `depends_on`, and `restart`.

Oct 12, 2017
Loading thumbnail…

Express server and serial port reading

This example shows a live data pipeline that reads sensor values from an Arduino over a serial port and exposes them through a simple HTTP endpoint. The Arduino sketch generates random temperatures between -5 and 15 degrees Celsius every five seconds and prints them to the serial monitor. Two JavaScript libraries, `serialport` and `express`, handle the communication: the serial port parser (`serialport.parsers.Readline`) captures each line of incoming data, while the Express server responds to root requests with the latest stored value. The result is a minimal web page displaying the current temperature reading.

Sep 29, 2017
Loading thumbnail…

Money chart

A donut chart displays the percentage breakdown of travel expenses, such as food, transport, and sleeping, with each slice’s arc labeled outside the chart. The tooltip reveals each category's percent, local currency amount, and equivalent in euros, based on a fixed exchange rate. Built with D3 v3, it uses `d3.svg.arc`, `d3.layout.pie`, and a color ordinal scale, rendering as SVG. Mouseover and mousemove events drive a custom HTML tooltip showing detailed cost data.

Mar 7, 2017
Loading thumbnail…

Example of prototype in JS

This example demonstrates JavaScript prototype-based inheritance and method overriding through a simple class hierarchy. It defines a parent `ClassA` and a child `ClassB` that inherits from it using `Object.create`, then overrides the `suchWow` method. The code also uses a global `App` object to track values shared across instances. After constructing instances of both classes and calling their methods, it outputs results using the console `log` API, showing how inherited methods affect instance and global state.

Feb 28, 2017
Loading thumbnail…

level

A circular progress indicator displays a 50% value in orange on a white background. The visualization uses D3.js to construct an SVG composition, layering paths and concentric circles to create a donut chart with tick marks. A large text element renders the percentage in the center. The code defines variables for size, border, stroke, and color, then uses `svg.append("path")` and `svg.append("circle")` with explicit `attr` settings to draw the shapes, and `svg.append("text")` for the label.

Jan 16, 2017
Loading thumbnail…

d3.zoom.translateExtends

This example demonstrates the zoom and pan capabilities of d3.zoom, using an SVG floor plan of the Grand Palace in Bangkok. The view is constrained within the map boundaries through the translateExtents method, preventing users from panning beyond the image edges. The code imports an Inkscape-generated SVG and applies d3.zoom with d3.event transforms to control the viewport. Zooming is limited to a specified scale range, and the SVG’s view group is updated accordingly to reflect the current transformation.

Aug 17, 2016
Loading thumbnail…

Drag & Zoom

This example combines d3-drag and d3-zoom on a canvas to let users pan and zoom a field of 2,000 points arranged in a phyllotaxis spiral—a sunflower-like pattern. Dragging the background pans the view, while dragging an individual circle moves it in world coordinates. The code distinguishes between pointer coordinates and the zoomed coordinate space using d3.zoom’s transform inversion methods, then renders points via a single canvas path with `context.arc`.

Aug 16, 2016
Loading thumbnail…

Pan & Zoom with click

This example shows a set of circles arranged in a phyllotaxis pattern within an SVG. Users can pan and zoom the view by clicking and dragging, with zoom controlled by the mouse wheel. The implementation uses the `d3.zoom` behavior applied to an invisible overlay rectangle, which updates the SVG group’s `transform` attribute via `d3.event.transform`. Clicking anywhere displays the client and SVG coordinates, converting screen coordinates to SVG space using the SVG’s `getScreenCTM` method. The data is generated programmatically using a phyllotaxis function, and the visualization is rendered with SVG circles.

Aug 9, 2016
Loading thumbnail…

Arduino shutter

This Arduino sketch operates an automated window shutter based on light and manual switch inputs. It shows a control loop that prioritizes an automatic daylight response, moving the shutter fully up or down when light conditions change, while also responding to physical wall switches with partial movements. The program uses the Arduino core library’s `pinMode`, `digitalRead`, and `digitalWrite` functions for I/O, along with `attachInterrupt` for switch detection and `Serial` for status logging. The logic employs simple state comparison to distinguish between sun and moon conditions, triggering relay outputs for up, down, or stop actions with predefined time delays.

Apr 28, 2016