xyquadrat.ch

Simulating my personal sun with Home Assistant

2026-03-23T00:00:00+00:00

I’ve bought myself a smart ceiling lamp a while ago (the Aqara T1M</a>, to be precise) and set it up with Home Assistant. However, in the beginning I’ve basically just used it as a normal lamp except that I sometimes changed the color temperature and brightness in the evening. This clearly was not using the setup to its full potential.</p>

Thus, I’ll quickly show you how I transformed this into a much smarter lighting design, which has two main features:</p>

In the morning, the lamp simulates a sunrise over the course of 15 minutes before my phone alarm rings (and of course it gets the phone time automatically).</li>

During the day, adaptive lightning kicks in: On midday the lamp shines cold light at maximum brightness whereas in the morning and evening it dims and shifts to warmer light.</li> </ol>
What you need</h1>
- An Android phone (For iOS you will have to find a way to sync the alarm time from your phone to HA. This forum post</a> should be a good starting point.)</li>
- The Home Assistant app on your phone</li> </ul>
  Simulating sunrise</h1>
  First, we’ll set up the surise transition. For this I use Ashley’s Light Fader</a>. Once you pasted the code into a script, you can then add a new automation which I call “Sunrise” which simply turns on the lights and runs the Light Fader to go to 100% brightness over 15 minutes (these are variables which you can configure in the Light Fader script). You do not need to add a trigger here - we’ll set up the way for triggering the sunrise next.</p>
  Get the Adjustable Wake-Up to Android alarm</a> blueprint. As the blueprint already tells you, you will have to enable the “Next alarm” sensor in the app under Settings → Companion App → Manage Sensors → Next Alarm → Enable</code>. Once you installed the blueprint, you can click on adding an automation and should see the “Adjustable Wake-up to Android alarm” option.</p>
  </p>
  As you can see, I’ve not only set the offset to -15 minutes and added triggering our “Sunrise” automation as an Action, but I’ve also included some additional conditions to both ensure the light doesn’t do a sunrise for random alarms throughout the day (if you are a late riser, I’d suggest you change the first condition…) and to not run the automation if my phone is not in the home network. For the second condition you could alternatively do this using zones and the “at home” status, but this works better in case since I rarely have location services turned on.</p>
  At this point, Home Assistant should automatically execute a beautiful fade-in 15 minutes before your alarm clock goes off!</p>
  Simulating the rest of the day</h1>For our second feature, we could probably script this ourselves - or we could simply rely on an excellent pre-built integration</a>. The only hassle about this is that the integration is available on the Home Assistant Community Store, which, if you don’t have it yet, you need to set up first</a>. Once HACS is installed and ready to use, you can search for “Adaptive Lighting” and install the integration. Then go to Settings → Devices & services → Add integration</code> and add Adaptive Lighting. Then click on the newly installed integration, and click on the settings icon of the instance you just created. There you can select which lights should be affected by the effect and tweak a lot of variables if you’d like (though the default settings work great for me).</p> The great thing about this is that the two features actually play together quite well - Adaptive Lighting is smart enough to pause its interference when other automations run, such as our sunrise automation, but then reactivates itself if you later in the day turn on the lights again.</p> Closing thoughts</h1> I really enjoy this setup, particularily during the winter times when the real sunrise occurs much later than my alarm goes off. Beyond this I can also really recommend the Aqara T1M - it’s a bright and high-quality lamp that isn’t super expensive and plays well with Home Assistant.</p>



Visualizing fractions with vanilla JavaScript
2024-11-15T00:00:00+00:00
Two years ago a friend of mine that worked as a math teacher reached out and asked how she could create visualizations of fractions similar to this example which is often found in school books:</p>
</p>
For the average person, this would not be easily doable.
Clearly, using a vector drawing program such as Inkscape or Adobe Illustrator would work, but would take significant manual labor for making variations.
Since I didn’t know what tool to recommend to her, I simply wrote a small website that could generate the desired visualizations.
I used vanilla JavaScript and canvas</code>, which despite being “boring” technology was super easy to work with, even though I did not know the API beforehand.
Today, I thought that it would be cool to integrate this tool in my main website, which I now did!
You can find the tool here</a>, along with the (unobfuscated, lightly commented) source code</a>.
If you know someone that would find this useful, feel free to share it with them.</p>
Here’s a screenshot if you’re too lazy to click the link:</p>
</p>


Simple selfhosted CI/CD with Woodpecker
2024-03-27T00:00:00+00:00
I’ve bought a new homeserver last week and have been busy transferring my data and services from my old trusty Raspberry Pi to my new Dell Optiplex 3070.
Previously I had a rather brittle, though very simple Continous Deployment (CD) setup:
webhook</a> would listen to incoming webhooks, which were configured to be automatically sent from GitHub when I pushed to a repo.
Then, it would simply run a shell script in response.
This worked reasonably well, but:</p>

I didn’t know if the deployment succeeded unless I ssh’d into the server and checked the logs.</li>
When a detail about the deployment of a repo changed, I had to manually adjust the script, which was on the server and not the repo.</li>
The shell scripts had some common overhead like setting up a temporary directory, cloning the repo, etc.</li>
</ul>
Thus, I decided to migrate to a more sophisticated yet still simple CI/CD solution.
I definitely wanted to host it myself, and it should preferably be open source.
There are a lot of options for CI/CD meeting that criteria: Jenkins</a> (the old titan, but can get really messy with the many plugins needed), Concourse</a> (cool but development has effectively stopped), ArgoCD</a> (designed for Kubernetes, which I didn’t intend to use), GitLab</a> (also has a ton of other features I don’t need), and many more.</p>
After a couple hours of searching and skimming through docs, I finally found a solution I really like: Woodpecker CI</a>.
It is a fork of the 0.8 version of Drone CI which turned half-closed-source afterwards and has since seen regular updates and improvements.
One cool aspect of Woodpecker is how design choices were made that keep the system simple yet do not impair its functionality:
The only authentication option is via OAuth2, i.e. you sign in via your forge (so GitHub, GitLab, Gitea or similar) and they use a SQLite DB for storing build logs and info so you don’t have to deal with another Postgres setup.</p>
To install it, you could usually simply use their docker-compose</code> file.
However, on my new server I’m using podman</code> instead of docker</code>.
In principle, podman</code> is fully compatible with docker</code> and could also run the docker-compose</code> file with podman-compose</code> - however, the native solution is to use Quadlets</a>.
These can be thought of as a simpler version of Kubernetes kubelets.
Basically, they allow you to do automatic container management but on a single-node scale without the added complexity of something like Kubernetes which is primarily designed for multi-node usecases.
To use Quadlets, you write one or multiple *.container</code> files and a .pod</code> file and put them in /usr/share/containers/systemd</code>.
When you then run systemctl daemon-reload</code>, podman</code> automatically generates systemd</code> service files that run and supervise the containers / pod.
Afterwards you can interact with the containers / pod like a regular systemd</code> service, which feels very natural.</p>
For reference, here are my Quadlet files:</p>
# woodpecker-agent.container
</span>[Unit]
</span>Requires=woodpecker-server.service
</span>After=woodpecker-server.service
</span>
</span>[Container]
</span>Pod=woodpecker.pod
</span>ContainerName=woodpecker-agent
</span>EnvironmentFile=/usr/share/containers/systemd/woodpecker/.env
</span>Exec=agent
</span>Image=docker.io/woodpeckerci/woodpecker-agent:latest
</span>Volume={CHANGEME_AGENT_DATA_PATH}:/etc/woodpecker
</span>Volume=/run/podman/podman.sock:/var/run/docker.sock
</span>
</span>[Service]
</span>Restart=always
</span></code></pre>
# woodpecker-server.container
</span>[Container]
</span>Pod=woodpecker.pod
</span>ContainerName=woodpecker-server
</span>EnvironmentFile=/usr/share/containers/systemd/woodpecker/.env
</span>Image=docker.io/woodpeckerci/woodpecker-server:latest
</span>Volume={CHANGEME_SERVER_DATA_PATH}:/var/lib/woodpecker
</span>
</span>[Service]
</span>Restart=always
</span></code></pre>
# woodpecker.pod
</span>[Pod]
</span>PodName=woodpecker
</span>PublishPort=8000:8000
</span></code></pre>
After installation, I followed the instructions to set up auth via GitHub</a>.
Then you can already add repositories which should be enabled for CI/CD - Woodpecker automatically creates a webhook for those such that your local server is notified when something happens.
In the respective repos you can finally write your pipeline using a very straightforward YAML syntax.
Everything is nicely containerized, but you can still easily interact with the host system using mounted volumes if you want to.
You can check out an example workflow from my Polyring repo</a>.</p>
Overall, this solution has resolved all my original problems:</p>

I have a web interface that I can access and see the status of all pipeline runs including logs.</li>
The pipeline definition now lives in the respective repos, which makes much more sense.</li>
Since the pipelines run in a container and the repo is automatically cloned by Woodpecker already, I don’t have any setup overhead more like in the custom shell scripts.</li>
</ul>
If you’re searching for a simple yet powerful enough CI/CD solution, check out Woodpecker</a>!</p>


less - A random tip
2022-12-08T00:00:00+00:00
To view files on the command line, you’ll likely want to use less</code>. Yesterday I had no internet on the train and didn’t have anything to do; so I read through the manual of less</code> (what a normal thing to do, right?). I found out a lot of interesting things less</code> can do, but the most useful thing I didn’t know about was the following: You can filter the lines of the output by pressing &</code> and then entering a regular expression matching the lines you would like to see. This looks super handy if you’re for example looking at a log file and want to see all lines containing “error” - just enter &error</code>. In comparison to searching with /</code>, it gives you more information at a glance. Quite wonderful.</p>
Extra Tip: You can use zless</code> to directly view compressed output without having to uncompress it first.</p>


Implementing h-index in SQL
2022-04-24T00:00:00+00:00
The h-index</a> is an easy-to-calculate metric that measures the impact of the publications of an author. The easiest definition is that it is the largest number h</code> such that the author has h</code> published papers with at least h</code> citations. It’s mostly used in the scientific community, but it can also be useful in other contexts. Recently I was asked to implement a h-index calculation functionality in a project of mine, and since I keep the relevant data in an SQLite database, I thought that it’d be convenient to use SQL to calculate the h-index.</p>
A useful restatement of the definition of the h-index is $$h =\max\lbrace i \in \mathbb{N}: f(i) \ge i \rbrace$$
where $f(i)$ is the number of citations of the paper with index $i$, which allowed me to come up with the following solution:</p>
SELECT </span>MAX</span>(Ranking)
</span>FROM</span> (</span>SELECT</span> Author, Citations, ROW_NUMBER() OVER (PARTITION BY Author </span>ORDER BY</span> Citations </span>DESC</span>) AS Ranking
</span>    </span>FROM</span> CitationData)
</span>WHERE</span> Ranking <= Score
</span>GROUP BY</span> Author
</span>ORDER BY </span>MAX</span>(Ranking) </span>DESC
</span></code></pre>
A few things are worth pointing out:</p>

You should use ROW_NUMBER()</code> and not RANK()</code>, because with RANK()</code> having multiple items with the same number of citations would lead to a wrong result.</li>
This is SQLite-compatible, but I’m quite certain that it should be trivial to use in another SQL dialect.</li>
Probably this isn’t the most efficient solution, but at least it’s one that is easy to understand.</li>
</ul>
I hope you found this useful. Feel free to send me feedback via mail</a>.</p>


Beautiful boxes in LaTeX with better tcolorbox defaults
2022-04-04T00:00:00+00:00
In my opinion, the default boxes you get with tcolorbox</code> aren’t that good-looking:</p>
</p>
So I eventually decided to dive into the extensive documentation</a> and make use of the myriad of config options to find something that looks cleaner. Here’s the result:</p>
</p>
The color on the left can be freely customized, of course. In my (german) Analysis cheatsheets</a>, I like to use the colorful version for important theorems, and have the grey version ready for less vital corollaries.</p>
</p>
If you like the look, feel free to steal the code:</p>
\usepackage</span>[most]{</span>tcolorbox</span>}
</span>
</span>\tcbset </span>{
</span>  base/.style={
</span>    arc=0mm, 
</span>    bottomtitle=0.5mm,
</span>    boxrule=0mm,
</span>    colbacktitle=black!10!white, 
</span>    coltitle=black, 
</span>    fonttitle=</span>\bfseries</span>, 
</span>    left=2.5mm,
</span>    leftrule=1mm,
</span>    right=3.5mm,
</span>    title={#1},
</span>    toptitle=0.75mm, 
</span>  }
</span>}
</span>
</span>\definecolor</span>{brandblue}{rgb}{0.34, 0.7, 1}
</span>\newtcolorbox</span>{mainbox}[1]{
</span>  colframe=brandblue, 
</span>  base={#1}
</span>}
</span>
</span>\newtcolorbox</span>{subbox}[1]{
</span>  colframe=black!30!white,
</span>  base={#1}
</span>}
</span></code></pre>
To then utilize the new style, use the following syntax:</p>
% replace mainbox with subbox for the grey version
</span>\begin</span>{mainbox}{A short title} 
</span>    Some exquisite prose you've written...
</span>\end</span>{mainbox}
</span></code></pre>


ETH D-INFK Ersti Exam FAQ
2021-12-23T00:00:00+00:00
Note: This is not an official resource. The content here is tailored for the semester HS21 and might not be up-to-date for other years. Also, lots of the points raised here are common sense, but maybe it still helps someone.</p>
In which subjects am I allowed to bring cheatsheets?</h3>
You may bring a handwritten (that is, either on paper or digitally with a tablet) cheatsheet of 6 pages in Discrete Mathematics and 12 pages in Linear Algebra. For Algorithms & Datastructures and Introduction to Programming, no cheatsheet is allowed.</p>
I haven’t started writing my cheatsheets yet. Am I in trouble?</h3>
If you’re reading this before New Year’s Eve, no. Writing the cheatsheets takes quite a lot of time, especially in Discrete Mathematics. But since it can also serve as a repetition, you should be fine - the majority of students only starts writing cheatsheets in Lernphase. Don’t begin writing just the week before the exams though!</p>
Can I copy another cheatsheet and save some time?</h3>
In Discrete Mathematics the requirement is explicitly “selbstverfasst”, whereas in Linear Algebra there is no such requirement. Honestly, it’s basically impossible for the examiners to control that. Still, the main value you get from a cheatsheet is not looking up lemmas during the test, but being forced to condense your knowledge of the subject onto a limited amount of paper. As such, copying a cheatsheet won’t be very effective.</p>
The eProg and A&D exams are incredibly long on myStudies. Why?</h3>
These exams will most likely have to be conducted in two separate groups. The first group will write the exam, then have to go another room and wait there for a while, whilst the second group starts to take the exam. This is due to the large number of registered students, and the limited capacity of computers available for examination at ETH.</p>
How much should I study per day in Lernphase?</h3>
An exact number of hours is hard to give, since the level of knowledge of students varies widely. Instead, the author prefers to give an upper bound: He believes that studying more than 6 hours a day is a bad idea; for the following reasons:</p>

The Lernphase is quite long. Overworking yourself will likely lead to a burnout.</li>
It is much more effective to distribute your study time over multiple days than to cram more on a single day.</li>
Very few students can learn in a concentrated, focused way for 6h (that means no distractions, no daydreaming, etc.). If you are such a student, you really don’t need any of my advice.</li>
</ul>
Do I need to study every day?</h3>
No.</strong> Quite the opposite - do not study every day, take a day per week off! Try to relax as much as possible on that day, so that you can recharge your batteries and be ready for another week of studying.</p>
Should I rewatch all lectures?</h3>
That’s a bad idea. It will take up a lot of time and you will probably not benefit that much.</p>
Okay, what should I do then instead?</h3>
(This is only one of multiple possible approaches.) Focus on solving old exams. You can find lots of them on exams.vis.ethz.ch</a>. When you realize you can’t solve an exam task because you just don’t understand the topic, reread the script and/or rewatch the relevant lecture. In addition, try re-solving the exercises from that topic.</p>
If you’re stuck, ask for help, in the respective Discord channel, in your study group if you have one or mail your TA. On the other hand, if you feel comfortable in a subject, try answering these questions. Being able to explain content to others means you really understood it.</p>
What should I do on the day of the exam?</h3>
Relax. You won’t suddenly learn everything you didn’t have time to understand on the day of the exam. Go to sleep early the day before; being well rested is crucial for delivering your best possible performance. Make sure you have all necessary things with you:</p>

pens (not just one, in case a pen breaks)</li>
your Legi</li>
the cheatsheet (if applicable)</li>
water</li>
some small snacks</li>
</ul>
At the risk of stating the obvious: Be there early enough.</p>
Where can I find summaries from other people?</h3>

rwgs.ch (all subjects)</a></li>
azurios.gitlab.io/page/summaries (A&D, eProg)</a></li>
n.ethz.ch/~dcamenisch (all subjects)</a></li>
github.com/soelmicheletti/ETH-Summaries (A&D)</a></li>
github.com/xyquadrat/eth-cheatsheets (A&D graph terminology)</a></li>
polybox by n.cavallini (italian summaries: DM, LinAlg)</a></li>
</ul>
Will I pass?</h3>
I don’t know, but I hope so! The Basisprüfung at ETH is tough, and Computer Science isn’t the easiest study program either. With that in mind, let me remind you of two things:</p>

If you made it until here, you already accomplished a lot. Of course this is easy to say as someone that passed, but it really is true. Be proud that you didn’t already quit.</li>
Your BP grade does not define you as a person. First, after you completed your studies and start working somewhere, nobody cares about your Basisprüfung anymore (much earlier than that already, probably). Second, you are not your grades</strong>.</li>
</ol>
I feel really overwhelmed or I am in a bad spot mentally. What to do?</h3>
It’s super important that you get help. You don’t have to and shouldn’t go through a difficult time alone. ETH offers various ways to support you. One great option is the Nightline</a>. You can call or chat with them most of the time throughout the week, and it’s fully anonymous. They aren’t professionals though. If you feel professional help is needed, do not hesitate to contact the Psychologische Beratungsstelle</a>. There are also further options listed on this page</a>. Again, please take care of yourself and do not wait for too long until you seek external help & advice.</p>
(This paragraph was taken from the Erstis FAQ</a>.)</p>
Good luck with your exams!</strong></p>


My experience as a Teaching Assistant at ETH
2021-12-17T00:00:00+00:00
This semester I’ve been teaching the course “Algorithms & Datastructures” at ETH for the first time as a Teaching Assistant. That means that every week, I’d lead an exercise session with about 25 people where I would explain the exercises, recap some theory and highlight common pitfalls. In addition, I would correct and grade bonus exercises. Here’s what I learnt, how I liked it, and what I’d do differently if I did it again (which I might, who knows!).</p>
Classroom teaching</h2>
Teaching is fun! I already thought beforehand that standing in front of a group of students and trying to get my point across would be something I like; especially given that I’ve been playing with the thought of becoming a part-time teacher at high school level after ETH for a while. And now, after a semester of actually teaching, I can conclude that I indeed do enjoy giving lessons, and that the “aha”-moments of my students had made the challenges of explaining well worth it.</p>
I also have seen how it’s critical to strike the balance between preparing every detail of your lesson and improvising everything. Sometimes it’s possible to walk into the room having barely looked at the exercises and hold a good, (hopefully) helpful two hour lesson nearly without any preparation. But then again that can easily come back and bite you; I distinctly remember a moment where a student was asking me to explain a more challenging exercise, I said “Yeah, sure”, started doing it and got lost halfway through. No one paid attention anymore, and I had to regretfully end the lesson not having explained the exercise.</p>
At the same time, the semester confirmed what I had already thought to be true earlier on: to be a good Teaching Assistant, it’s not necessary to know everything</em>. It’s fine to not have an answer immediately, and it’s also fine to be wrong (at least occasionally).</p>
Correcting exercises</h2>
Ugh. I don’t like correcting stuff. Of course I know that it’s required, and that a good correction can be very helpful. But the hours I spent every week on wading through proofs that ranged from basically perfect to me barely understanding the idea after multiple perusals weren’t exactly enjoyable.</p>
</p>
Ah yes. My students were the best, absolutely, but sometimes a slightly cleaner solution wouldn’t have hurt.</p>
A note on Kahoots</h2>
In 2021, seemingly no lecture or exercise session can avoid using the omnipresent quiz platform Kahoot</a>. Now see, I get it. It’s fun to compete and win, and it’s great to activate all students instead of only hearing from the select few that are brave enough to raise their hand. But honestly, I really don’t like Kahoot. First, they aggressively try to upsell you on a hundred different subscriptions, and they at one point just forbid me to host a quiz for more than 10 players, requiring me to pretend to be a K-12 teacher. (Oh, and don’t get me started on them recommending wonderful</em> “Elsa in Frozen 2” quizzes to me.) But more importantly, I think that Kahoots are not a good didactic tool</strong>.</p>
The simple reason for that is the fact that the best way to win a quiz is not by thinking thoroughly about your answer but to click as fast as possible once you have a decent guess. That’s neither how the exams nor real life works. As such, you can easily win a Kahoot even if others have more correct answers in total, and that makes Kahoots unrepresentative of actual student performance, which is exactly</em> what you as a teacher want to know.</p>
Anyways. Rant over.</p>
Organizational matters</h2>
Eh, fine. I would have appreciated knowing which exercises will come next in advance, so that I could tell students what I want see in their approach. Oh, and it turns out that an actual grading scheme that includes how one should grade common errors would be very helpful. But I get that this requires a lot of work, so I don’t think it’s unreasonable not to do that.</p>
Ah, and I always got paid on time (in contrast to other subjects where this can take multiple months… Parallel Programming, I’m looking at you).</p>
What I would change</h2>
I’m not certain it’s sensible to always discuss all bonus exercises. We were explicitly told by the Head TA to do so and to also discuss most non-bonus exercises, but due to the large gap of skill (some people solved the exercises without any problems and are bored when explaining, whereas others didn’t even try and thus don’t benefit either) I think it might make more sense to focus more on theory recaps.</p>
I’d like to have some sort of more direct channel of communication with my students. It’d be great to have students tell me in advance what they haven’t understood yet, because then I can actually prepare these topics.</p>
Finally, I believe there are still a lot of potential synergies among us TAs that we could use to lower our work load and improve our lessons - sharing notes, additional resources, explanations on solutions, etc. (Ah, you can find some of my stuff on xyquadrat.ch/eth/and</a>, by the way.)</p>
Closing thoughts</h2>
Teaching, even if in a small setting like in my case, is very fulfilling. It’s great to see students understand something because you were able to get your point across. A great TA can make a course easy, whilst a bad one can rob you of all your motivation to study. Whilst I might not have been the best or even a great TA, given that I still had about as many people in my session at the end of the semester as in the beginning, I think I’m also not that bad. And that’s pretty cool, honestly.</p>


Running an appropriately sophisticated Minecraft server in 2021
2021-12-13T00:00:00+00:00
Even more than a decade after its release, Minecraft continues to be popular and receives regular updates.
A healthy modding community (if we conveniently ignore debates about Forge versus Fabric) produces a steady stream of huge modpacks that use Minecraft merely as a game engine to build their own experiences on top. But sometimes, all you want is to play good old Vanilla Minecraft, go farm some diamonds and be happy if you manage to build a house that looks better than a dirt block.</p>
From the perspective of a server admin, things have changed in the last years, though much of the improvements that have been made have never reached a large
number of servers. I want to give a concise overview of what the best options (in my view) for various aspects of running a server in 2021 are.</p>
</p>
Hardware</h2>
No hardware, no server. Realistically speaking, you’ll want to have something with the at very least 1GB of RAM. Even that will not be a very pleasant experience if you have more than 2-3 players. At 4GB+ we’re starting to get into the reasonable territory, with about 8GB being a good choice for up to about 20 players and a modest set of plugins. More than that doesn’t hurt, of course. In terms of CPU power, single threaded performance matters more than additional cores, but as a rule of thumb: anything that can run Minecraft decently as a client can also run it as a server.</p>
Operating System</h2>
Just use some flavor of Linux. Ubuntu Server Edition or Debian are solid choices. I would not recommend using graphical desktop environments (unnecessary loss of performance) or Windows / MacOS - these really aren’t meant to be server operating systems, and their server variants are on life support at best.</p>
Server implementation</h2>
</p>
Originally, you would be using the offically provided server binary from Mojang, but these days are long gone. Spigot with their extensive plugin support was a great choice for a long time, but by now most new setups have moved on to Paper</a></strong>, a fork with better performance and plugin compatibility. There</a> are</a> numerous</a> other</a> forks</a>. Really the only other significant fork/project I’d consider apart from Paper is Purpur</a> which has a million config tweaks (including some that make every mob rideable…) - but given that I personally don’t need those, I stick with Paper. Most forks either have a tiny community, include patches that break plugins / expected behavior or have a questionable code quality.</p>
Plugins</h2>
In principle, just running a Paper server without anything is already enough, and some will be happy with such a setup. But most server populations demand some</em> amount of plugins, for example because they aren’t good enough at the game to survive a night on Hard</del> they don’t want to require everyone to sleep to skip the night, or because they want permissions to /tp</code> but you’d (rightfully) prefer not to give everyone OP rights. Personally, I like to roll with these four plugins:</p>

EssentialsX</a> has a nice selection of “a bit of everything”, including warps and convenience features such as /otp</code> that teleports you to offline players.</li>
LuckPerms</a> is the permissions plugin of my choice. Maybe make a trusted</code> group that has access to teleporting and then some moderators</code> that can change their gamemode? Whatever permissions you want to hand out, LuckPerms probably covers them. (Tip: You can find the EssentialsX permission list on this handy site</a>.)</li>
sleep-most</a> is a simple but very customizable sleep skipping plugin. It does one thing, and it does it well.</li>
Vault</a> is just an API for Permissions / Chat / Economy, but some features of EssentialsX need it.</li>
</ul>
Tweaking performance</h2>
Just Paper on a reasonably fast server should already provide a good experience for your players. But there are lots of improvements you can make to enhance performance. There’s an excellent extensive guide on optimization</a> by YouHaveTrouble. To save you some reading, here are the 3 most important things to change:</p>

Use the Java startup flags by Aikar (here’s a handy generator</a>). Quite a bit of testing has went into these flags, and they are widely accepted to be the gold standard (until ZGC, a comparatively new garbage collector, becomes mature enough).</li>
Pregenerate your chunks. Chunky</a> makes this very easy. This helps a ton in my experience, especially when there are multiple players exploring the world.</li>
If you run a redstone-heavy server, you’ll benefit a lot by setting use-faster-eigencraft-redstone: true</code> in your paper.yml</code> which enables an alternative implementation of the redstone logic that is much more performant.</li>
</ul>
Miscellaneous things</h2>

tmux</code> is helpful because otherwise the server will stop when disconnecting over SSH.</li>
Consider using a whitelist or WorldGuard to protect your server against griefing.</li>
Ask your players what they want. Unless you’re a dictator.</li>
</ul>
Backups</h2>
See, it’s kind of a mistake to put this at the very bottom. Backups are important. When your server crashes and the world save is corrupted, your players won’t like hearing that the life-sized recreation of Atlantis that they’ve been working on for weeks is irrevocably lost. There is a myriad of options for backing up stuff, from simple Bash scripts that make a .zip</code> file to enterprise-grade redundant systems. I personally really like borgmatic</code></a>, which is a friendly interface to borgbackup</code>. Throw their systemd unit file in the right folder, set the timer to once per day when everyone is sleeping, and you’re good to go.</p>
Future areas of work</h2>
Two big things are missing here:</p>

Autorestarting your server after a crash or power outage</li>
Monitoring and alerting (preferably selfhosted)</li>
</ul>
I’ll be back with another blog post once I got those set up the way I like it.</p>


Reading files in Zig for Advent of Code
2021-12-01T00:00:00+00:00
Zig</a> is a lovely low-level language I’ve recently learned about, and what better way is there to learn a new language than to use it to solve Advent of Code</a> problems. Alas, I set out on solving the technically very easy first task, managing to complete it in less than 15 minutes.</p>
Or so I thought. Whilst I did have a rough idea of Zig’s syntax, and I had no problem writing loops or functions, I conveniently overlooked the issue of getting the input into my program. For reference, Day 1 had a list of integers as input; nothing difficult to parse per se. But my unfamiliarity with Zig led to serious problems when I tried to read said list of integers into an array.</p>
I’ve tried various solutions, some of which seem deprecated whilst others should in theory work but I must have made mistakes whilst implementing them (I got lots of type mismatch errors), because it took me 45 minutes of trying before a helpful tip from a colleague that also decided to do AoC in Zig finally got me to a working snippet of code. (Once I had the input parsed, the two tasks were indeed easy and I managed to solve both of them within a few minutes.) To possibly spare someone else this frustrating process, the actual working code is as follows:</p>
const</span> std = </span>@import</span>(</span>"std"</span>);
</span>const</span> data = </span>@embedFile</span>(</span>"/path/to/file"</span>);
</span>
</span>pub fn </span>main</span>() !</span>void </span>{
</span>    </span>var</span> lines = std.mem.</span>tokenize</span>(u8, data, </span>"</span>\n</span>"</span>);
</span>
</span>    </span>while</span>(lines.</span>next</span>()) |line| {
</span>        </span>var </span>x </span>: </span>i64 </span>= </span>try</span> std.fmt.</span>parseInt</span>(i64, line, </span>10</span>);
</span>        </span>// do something with x, e.g. append to an ArrayList
</span>    }
</span>}
</span></code></pre>
Remark: This solution embeds the contents of the file into the actual binary. This is not an issue at all for Advent of Code, but may very well not be the desired behavior for general file I/O.</p>


Getting PHP to work in subfolders with nginx
2021-10-21T00:00:00+00:00
If you have nginx</code> as your reverse proxy of choice (like I do) and you for one reason or the other have to run PHP code on your website, you might have a configuration in your nginx config file like this:</p>
location ~ \.php$ {
</span>    include /etc/nginx/snippets/fastcgi-php.conf;
</span>    # or php7.x if you use old versions of PHP
</span>    fastcgi_pass unix:/run/php/php8.0-fpm.sock; 
</span>}
</span></code></pre>
which works nice and dandy as long as your PHP code is not in a subfolder. But that occurs fairly often, and when it happens, the .php file won’t get passed to php-fpm</code> and thus only displays as a text file. Not nice. To correct this, you can just have another similar block nested inside the subfolder config block, like this:</p>
location ~ /subfolder/ {
</span>    root /folderroot;
</span>
</span>    location ~ \.php$ {
</span>        include /etc/nginx/snippets/fastcgi-php.conf;
</span>        fastcgi_param SCRIPT_FILENAME $request_filename;
</span>        # or php7.x if you use old versions of PHP
</span>        fastcgi_pass unix:/run/php/php8.0-fpm.sock;
</span>    }
</span>}
</span></code></pre>
and that should make PHP work in these subfolders too, because php-fpm</code> will correctly pick up those requests. How delightful (or not, depending on your stance towards PHP).</p>


Announcing the Polyring Blogging Challenge
2021-09-19T00:00:00+00:00
</p>
Fellow Polyring members: Do you have a blog, but you only have two or three posts? Do you, like me, write something only once every month or so? Would you like to blog more, but just haven’t gotten around to it? Then maybe you should join the new Polyring Blogging Challenge! Throughout the coming semester at ETH, your challenge is to make at least 10</strong> blog posts in the 14</strong> weeks of the semester. And, of course, if you do so, you get a fancy prize.</p>
The rules are simple:</p>

You must be a member of Polyring to participate. (You can join at polyring.ch</a>, if you haven’t yet.)</li>
You have to make at least 10 blog posts until 24.12.2021, 23:59.</li>
Particularily high quality posts such as this introduction to TypeScript by Lukas Möller</a> count as 3 blog posts. That means that 1 high quality post per month nearly gets you there, too. I decide what falls into this category.</li>
“Hello world”-esque posts do not count.</li>
If you complete the challenge, you’ll get an exclusive sticker (design not finalized yet) and a very</em> exquisite bar of chocolate (Choba Choba Spicy Strawberry, if you wanna know). Details on how that’ll be distributed will follow later.</li>
</ul>
You can blog about anything, really. Tell the world what you are learning at ETH, show off your pet projects, ramble about technology and society… There are no limitations.</p>
I hope that this will cultivate lots of great content, and will be a fun experience for everyone that participates.</p>


Solving a simple linearizability problem
2021-07-06T00:00:00+00:00
Let us tackle the following problem:</p>

Give a two-thread history that is sequentially consistent, but not linearizable. Use a single atomic register r</code> that initially contains the value zero and supports the operations read()</code> and write()</code>. (HS20)</p>
</blockquote>
To be able to solve this, we must recall what it means for a history to be sequentially consistent</em> and what it means to be linearizable</em>.</p>

A history H is sequentially consistent</em> if it can be extended to a history G that is equivalent to a legal sequential history S by</li>
</ol>

appending zero or more responses to pending invocations that took effect and</li>
discarding zero or more pending invocations that did not take effect</li>
</ul>

A history H is linearizable</em> if it can be extended to a history G that is equivalent to a legal sequential history S with $\to_G \subset \to_S$ by:</li>
</ol>

appending zero or more responses to pending invocations that took effect and</li>
discarding zero or more pending invocations that did not take effect</li>
</ul>
These two definitions are very similar. The additional constraint that linearizability brings to the table is that $\to_G \subset \to_S$, which means that we cannot reorder operations done by different threads. For sequential consistency, we can reorder operations by different threads</em>, but not</strong> those in the same thread (so program order has to be respected).</p>
Alright. We thus want to find a history where we have to reorder stuff for it to be equivalent to a legal sequential history. This way, we keep sequential consistency, but we don’t have linearizability.</p>
A possible solution could be</p>
A: r.write(1)
</span>A: void
</span>B: r.write(2)
</span>B: void
</span>A: r.read()
</span>A: 1
</span></code></pre>
since we can reorder this to</p>
B: r.write(2)
</span>B: void
</span>A: r.write(1)
</span>A: void
</span>A: r.read()
</span>A: 1
</span></code></pre>
which is then a legal sequential history. Because we have to reorder invocations across threads to make this work, the history is not</em> linearizable, but it is</em> sequentially consistent, just like the exercise demands.</p>


Optimizing font file size with glyphhanger
2021-04-27T00:00:00+00:00
A good font choice is essential to a good-looking website. xyquadrat.ch surely wouldn’t look even remotely trustworthy if I used Comic Sans, would it?</p>
</p>
It… really doesn’t fit.</p>
Actually, it’s pretty easy.</h2>
So let’s assume that you decided to find a nice font for your website; something that fits your style of content and is well readable. This is luckily no longer that much of a challenge - Google Fonts</a> and similar sites have hundreds of different fonts that look great and are free for you to use. In my case, the font I settled on was Merriweather</a>.

Google Fonts offers you to include the fonts directly from their CDN, which only requires you to copy-paste the appropriate code into your HTML or CSS (depending on the method you are using). If you do this, then you’re done, there’s not much to optimize, and you can safely close this tab now.</p>
But maybe that’s not what you want to do. At least it was not what I wanted to do; my general credo is: if I can self-host something, I’ll self-host it. Also, if you self-host your fonts, you don’t need exceptions in your CORS headers. The tidyness of these headers is something (however irrational that may be) I really like.</p>
Selfhosting it is, then.</h2>
To self-host the fonts, you’ll first want to download the fonts locally. For some weird reason, the standard format for fonts downloaded from Google Fonts is .ttf</code>. TTF might be a fine format for local fonts you’d use in a word processor; it surely isn’t well-suited for the web</a> though. You should use WOFF2 (and, if you expect to have IE 9 - 11 traffic, WOFF as a fallback) instead. These are basically the compressed versions of TTF, and they are strictly superior to TTF for the web.</p>
So you’ll have to convert the .ttf</code> to the appropriate formats. And if you’re already at it, you could also get your hands dirty and optimize the size of your font a bit more. (Before optimization, my fonts were usually the biggest chunk of my site, of course especially for text-only posts.) To do this, you can use the awesome tool glyphhanger</code>. (You can install it via npm</code></a>. It’s quite heavyweight since it uses puppeteer</code>, but it excels at its job.)</p>
Then, you can easily convert the .tff</code> to a .woff</code> and .woff2</code> file with glyphhanger --formats=woff,woff2 <input file></code>. But that still leaves files that contain quite a lot of unneeded information - namely unnecessary symbols (or more precisely glyphs). For example, the myriad of accents used in Eastern Europe and other weird Unicode ranges that you’ll probably never use are still in there. You can easily get rid of those by subsetting</em> your fonts with glyphhanger</code>. If you only need “normal” Latin characters, glyphhanger --LATIN --formats=woff,woff2 --css <input file></code> will both subset the fonts appropriately and also generate a @font-face</code> CSS declaration that’s ready to use.</p>
Personally, I managed to reduce the data transferred for my fonts from 180KB</strong> to 70KB</strong> - certainly a nice improvement that Google PageSpeed Insights also liked. There is one significant downside with this approach: If you selfhost your fonts, the browser cannot use a cached version of the font. With the very common web fonts such as Lato, Open Sans or Roboto, this might lead to a net increase in bandwith usage. Since few sites use Merriweather as their font, this is much less of a concern for my setup, and thus I’ll continue to selfhost my fonts, for better or worse.</p>


Theming support for the Polyring widget
2021-04-24T00:00:00+00:00

Honestly that’s not a fully satisfactory solution; it’d be better to have a single parametrized widget that one could easily adapt to any design with a few simple arguments.</p>
</blockquote>
That’s what I wrote in my post a few days back about building Polyring</a> in regards to the widget members of the webring can embed in their page. I also mentioned that Luca (gewlar)</a> was working on improving the situation. Only a day later, he already sent a pull request</a> which did exactly that.</p>
The clever solution allows you to pass a theme</code> parameter to the webcomponent. You can either use one of the “official” themes by passing theme="default"</code> or theme="dark"</code> to the widget, or mix it up with your own style by passing a link to a .json file: theme="<link-to-json>"</code>.</p>
There are six variables for members to modify:</p>

--background-color</code></li>
--outer-border-color</code></li>
--inner-border-color</code></li>
--href-color</code></li>
--href-color-active</code></li>
--text-color</code></li>
</ul>
These should be rather self-explanatory; you can look up the default theme JSON</a> to see the simple structure your file should have. A neat feature Luca also implemented is that the logo will adjust its color accordingly.</p>

    
Member of the Polyring</a> webring</p>
</webring-banner>

xyquadrat.ch

Simulating my personal sun with Home Assistant

What you need</h1> A smart light with adjustable brightness</li> A Home Assistant setup in which you’ve integrated the lamp</li>

Visualizing fractions with vanilla JavaScript

Simple selfhosted CI/CD with Woodpecker

less - A random tip

Implementing h-index in SQL

Beautiful boxes in LaTeX with better tcolorbox defaults

ETH D-INFK Ersti Exam FAQ

How much should I study per day in Lernphase?</h3> An exact number of hours is hard to give, since the level of knowledge of students varies widely. Instead, the author prefers to give an upper bound: He believes that studying more than 6 hours a day is a bad idea; for the following reasons:</p>

Do I need to study every day?</h3> No.</strong> Quite the opposite - do not study every day, take a day per week off! Try to relax as much as possible on that day, so that you can recharge your batteries and be ready for another week of studying.</p>

Will I pass?</h3> I don’t know, but I hope so! The Basisprüfung at ETH is tough, and Computer Science isn’t the easiest study program either. With that in mind, let me remind you of two things:</p>

My experience as a Teaching Assistant at ETH

Running an appropriately sophisticated Minecraft server in 2021

Server implementation</h2> </p>

Miscellaneous things</h2> tmux</code> is helpful because otherwise the server will stop when disconnecting over SSH.</li> Consider using a whitelist or WorldGuard to protect your server against griefing.</li>

Reading files in Zig for Advent of Code

Getting PHP to work in subfolders with nginx

Announcing the Polyring Blogging Challenge

Solving a simple linearizability problem

Optimizing font file size with glyphhanger

Theming support for the Polyring widget

Do I need to study every day?</h3>
No.</strong> Quite the opposite - do not study every day, take a day per week off! Try to relax as much as possible on that day, so that you can recharge your batteries and be ready for another week of studying.</p>