#DieLog #3 Live stats & Status polling
Picked up where I left off with a working dashboard that could start/stop containers via HTMX, but the status label was static — no way to tell “starting” from “running,” and CPU/RAM usage was still hardcoded placeholder data from servers.json. Today’s session closed both gaps.
Starting vs. running. Turns out docker start marks a container as running in .State.Status almost instantly — the process is alive, but a Minecraft server still needs real time to generate the world and load plugins. Digging into docker inspect showed the missing piece was .State.Health.Status (starting / healthy / unhealthy), which reflects whether the game actually responds on its port. Combining both fields gives an accurate starting → running transition instead of a status that lies for the first 30+ seconds of boot.
Polling instead of guessing. Wrote pollUntilStatus, a goroutine kicked off after a successful docker start/stop call. It checks container status every 5s and writes the result back into the shared server map until it hits the target state, then exits — no wasted background work once the goal is reached. When the target is running, it hands off to a second goroutine, pollStats, which polls docker stats –no-stream every 5s for as long as the server stays up, and quietly stops the moment status flips away from running.
What went wrong (and got fixed). Two real bugs, both classic Go concurrency traps:
A deadlock in pollStats — called Lock() on the mutex, then called Lock() again a few lines later without releasing the first one. Everything just hung. Fixed by splitting reads (RLock) from writes (Lock) into properly scoped, non-overlapping sections.
An HTMX polling storm — the status fragment carried hx-trigger=“load, every 5s” on itself, so every 5-second refresh re-triggered load instantly, turning “every 5 seconds” into “every few milliseconds.” Fix was moving load to the outer placeholder only, leaving every 5s on the fragment that gets swapped in.
Numbers sanity check. docker stats reported ~0.7% CPU / ~10% memory for an idle vanilla server, while the system monitor showed 40–60% CPU and 5GB RAM at the same time. Looked alarming until it became clear those are two different measurements entirely — docker stats is scoped to the one container, the system monitor is the whole machine (browser, editor, Docker daemon, everything). Once isolated, the container numbers checked out fine.
Net result: dashboard now shows live, accurate status and live CPU/RAM bars over HTMX auto-refresh, all backed by two lightweight, self-terminating goroutines instead of one permanent background loop. Also switched from VS Code to Zed mid-session over memory leaks — anecdotally, Zed didn’t break a sweat running alongside the Docker container, something VS Code couldn’t handle before.

base UI, client side routing, login and placeholder GUI

In our serever i reserved two routes, one will send you to localhost:8080/static/login.html

there you go to the login validatioin with our nnonperamnently hardcoded data.
It willmhit the endpoint to validate and rerout to localhost:8080/dashboard

now.

I will connect the html to html/template base to get refreshed data from our go server, and update in time.

What would i like today to manage is make working Start stop button. THATS IT. it will be a lot of work but go easier from there

This was long (DieLog #2)

What did we achive ?
Go serrver -> reads status of current container,

start, stop handlers, with curl on the endpoint.
Working status reader.

AUTH, middleware, and cookie token flow to make sure our user is our user.

Whats up next? we are aprochaing the great work of frontzend.

We have a bit of an issue tho -> HTMX wants an HTML fragment, were sending JSON strings so we have to fix that.

And now i quote claude “Look at my frontend skill so the auth pagfe doesnt endup like a 5 year olds crayon project” im lowk fried.

Auth, middleware, cookies completed (dieLog #1)

go server now supports these actions.
you might ask. BUT WHATS NEXT

i will tell you

1. Docker integration
   2.Install setup flow
2. Small stuff to fix

99999……..fronten
why ? we have to have a working api to make it usable.:)
Peace, im out

HOLDUP DID I COOK (dieLog #2)

Finished : automatic “INDENT” and “DEDENT”

• enables codegen to space out blocks of code.

: “IF” statement

• uses the new automatic system trough recusion

: MAIN() function search

• for stzarting function for a basic C sytax.

: Math OPERATORS

• such as “is” “is_not” “grater_than” less than… you get the point.

Since in suffer levels 1 and 2 are used basic symbol types “<,>” etc, i didnt bother much checking the correctnbes of the implementation.

CODE EXAMPLE (with the new stuff):
-fineLang ->

SUFFER: two
;
FUNCTION main():
let x = 5
if x > 3:
print(x)
if x > 4:
print(x)
let y = 6
if (x add y > 10):
print(“hi”)

• to C ->

#include <stdio.h>
int main() {
int x = 5;
if (x > 3) {
printf(“%d\n”, x);
if (x > 4) {
printf(“%d\n”, x);
int y = 6;
if (x + y > 10) {
printf(“hi\n”);
}
}
}
}

INTO THE ULTIMATE COMPILED STATE ->

5
5
hi

To be honest.

this was a very complicated test case, and i wouldnt lie if i said that If this fails i wouldnt be surprised

THATS IT FOR TODAY!! thanks you for your time and have a nice day :>)

DieLog

Heres what majestic stuff have we done

Finelang now accepts CALCULATING OPERATORS

and CHAINED calculated operation.

lets give ourselves a representation
let x = 5 add 7 multiuply 9
let y = x subtract 67

this adequetly transforms the code to the correct math operators, and let our big dawg figure out the operations.
’
lets see for ourselves.

fineLang ->
´´´
SUFFER: two
;
FUNCTION main():
let x = 5.5 times 2
let y = x divide 6
print(x)
print(y)
return 0
´´´

into correct C
´´´
#include <stdio.h>
int main() {
float x = 5.5 * 2;
float y = x / 6;
printf(“%f\n”, x);
printf(“%f\n”, y);
return 0;
}
´´´

this was amazingly painfull to do and im glad it works :)

tomorows work is automationg codegen tabs / spaces, and being able for new code blocks

Float as pieces

i modified our regex in tokeniser to accept numbers 0-9 with a dot inbetween and number(s) after

this gets by tokeniser recognised as pices and codegen now correctly outputs it with F in the C printf command.

The biggest problem C standartly takes 6 nuámbers after the dot so from x=5.6 you get
5.600000.

That aint a big of a deal.

Todo:

• Implement math opoerations, that can be cahined.
• Impement cloasable block operationh (function doesnt run until the end of a file)

This also allows for automatic tabs in codegen instead of manual and allows implementation of someting like if/else

We got wokring avriables?

so for levels 1 and 2 you dont need to define the type of variables, we right now have

1. words - char*
2. whole - int

Incoming 3. ‘pieces’ for float

in the codegen i designed a list lookup where if you create a vaiable with let its type, datatype name and value can be looked up for easyprint.

parser had MAJOR fallback flaws witch i also patched.

There was one teeny beeny mess up where i had if statement that basically said if (string) “IDENTIFIER” is equal to the equal sign. :(

BUT WE KNOW FINELANG WORKS. tomorrow there comes maybe piees data type and “if” “else” statements ?

THIS CONCEPT WORKS

so i completed the codegen to actualy buuild the C code, and made in main.py to open a new file called output.c

Next output.c is compiled with gcc trough subprocess. if compilation succeeds we also call the binary itself, and THTS IT.

next steps are to recognise and properly save variables and then be able to print them

What happened

belive it or not, i made a working parser that works with all out keyword comands function, return,print, and let.

Function- sadly right now couts as a non ending function so it ondly recursivly calls parse fro rest of the file, but thats easy solvable issue.,

Parser now generates correct AST, witch after building Codegen can be correctly transpiled into C

heres a comparison code w/ AST

code:
SUFFER: two
;
FUNCTION main():
let x = 5
print(“hello world”)
return 0

AST:
[{‘type’: ‘function’, ‘name’: ‘main’, ‘body’: [{‘type’: ‘let’, ‘name’: ‘x’, ‘value’: 5}, {‘type’: ‘print’, ‘value’: ‘hello world’}, {‘type’: ‘return’, ‘value’: 0}]}]

as we can see theres a list (body) inside the whole list as a part od the main function. This is enough to generate correct C and run it !

since last time i also implemented errors.py witch is only a library of custom errors dataclas. the point of that is that with mopre complexity in our programming language the more feedback we need to guive to the coder to tell him “hey you did this wrong!” instead of “you fricked up” because that wouldnt be fun

in the picture we can see my terminal as a proof of the working error and parser.

someone told me theres no need for a wirtual enviroment, but its better to keep track of stuff even tho we wont be needing any more packages. BUT if we did then its good practice after compiling the compiler to have all the necesary packages already installed.

so, i implemented a error checking if string is open, and updated my tokenizer to recognise a group of words in “” aqs one big string. implemented error witch is called on unclosed strings

I have “completed” our tokenizer and validator that ensures correct “SUFFER” declaration. if we tokenize the code from our first devlog we get this

today i started to make basic “compiler|” for level 1 and 2. if you want to see how finelangs going to work there is a attached snippet and you can see for yourself the whole idea in readme of the project