Forem: Tom Nijhof

A Solo Game Developer who uses only Free & Open Source Tools

Tom Nijhof — Sun, 04 Jan 2026 19:21:26 +0000

I am amazed by the current state of open-source tooling. It came a long way from “just a hobby project made in the attic”. Recently, I spoke with Marcel Visser from Dot Asterisk. He creates not only the code but also the 3D assets and music, all by himself, using only open-source tools.

His latest game, Juggle Star DX, was also built with only open source tools as a solo developer! With even an Android release!

Screenshot of the opening screen of Juggle Star DX

Why open source?

Did it feel like a constraint to work with only open source?

Not really, only at specific times. Unreal has had much more time to invest in graphical maturity, for instance, but I don’t miss it in Godot. Blender has been amazing as of late, so has Godot.

Was budget or principal a big factor in going open source?

The budget to buy a lot of commercial products is there. Not interested, though. These are my default tools for small projects and studying. They also work well enough when going for something bigger. They suit my workflow.

Game Engine: Godot

Godot was first released in 2014 by two Argentine developers, Juan Linietsky and Ariel Manzur. Over the years, the team has grown all over the world to make and maintain this open source game engine.

If we look at the trend of GDScript (a script specially made for Godot) on GitHub, we can see the growing popularity of Godot.

Graph showing the increasing number of pushes done to GitHub with GDScript.

What was your experience with Godot?

At first, my experience was not great, this was in the 3.x days. But with 4.x, especially since 4.3, things have gotten really good and stable. Besides, the occasional crash worked great.

3D assets: Blender

Blender is 3D computer graphics software. Fully free of charge and open source. The Dutch software developer Ton Roosendaal is the main developer who launched it in 1994 as part of the now-defunct NeoGeo company. The project went through a few phases till it ended up in the non-profit Blender foundation where in 2002 it became open source.

Blender stays developing with about 3 million a year, mainly thanks to sponsors, like AMD, Nvidia, Intel, Apple, Epic Games, and Meta, but also a significant part from individual contributors.

The Blender logo

How is Blender?

Blender has been an absolute blast. Since 2.8, the workflow has been intuitive enough to work with, and since 4.x, everything’s been really streamlined. It’s a great tool. I only wish there were better support for AMD cards on Linux, because I don’t want to deal with the wonky proprietary drivers. I’m stuck with CPU rendering in Cycles.

Did you hide your first donut in the game?

Haha, no, not Blender-ready for sure, but I did re-use older stuff I made earlier!

For some context: A very popular Blender tutorial is by Blender Guru; his first tutorial is always to make a donut.

Audio

What did you use as audio software?

I did use FL Studio for one song; this was the only time I used the closed-source software in this product. After that, I used MuseScore and Audacity for the heavy lifting and some light touches with the audio programming in Godot.

Audio: MuseScore

MuseScore Studio is the open source software of MuseScore created in 2008 by Werner Schweer, Nicolas Froment, and Thomas Bonte (from Germany, France, and Belgium).

Besides the open source project, the MuseScore company is a social sharing website. Here, sheet music, lessons, an AI music assistant, and other music-related products are shared and sold.

A sample of MuseScore Studio showing how sheet music looks within the application. The music is “Green Eggs” by Marcel Visser.

What made you choose MuseScore?

MuseScore is not an application I would recommend to serious musicians, nor does it have the best and most sustainable business model, but does the job well enough. For me especially important to get sketches out quickly because my workflow is with sheet music. It makes it a lot easier for me to think in intervals and parse my harmonies semantically than doing things in a DAW (digital audio workstation), where things are obscured a bit by enharmonicism.

How did the experience differ between FL Studio, and MuseScore with Audacity?

FL Studio is also a bit looked down upon in the DAW ecosphere, but it works well enough for me to get out some electronic production that sounds good to me. I also appreciate the very consumer-friendly commercial strategy. Because of semantic erosion, actual part writing is harder, but usually I’m past that phase when switching to there (barring some embellishments or things that start to sound too dissonant because of the instrument chosen).

Video editing: Kdenlive

Kdenlive is a video editing software part of KDE. It was launched in 2003 by Jason Wood, but was stopped for 2 years till Jean-Baptiste Mardelle picked it up in 2005, who is still part of the current development.

It is part of the German non-profit KDE e.V.

Video editing: Kdenlive — What made it so unpleasant? Would a closed-source alternative be better?

Using Kdenlive, especially in the past, was quite crash-prone. The UX is, unfortunately, a bit hammy with having to configure everything over and over. It has a palette of video effects, but something that I would consider simple, like shaking, isn’t present, and you have to work your way around that. A lot of things are missing, like having a default export folder, quick presets, user-friendly encoding settings (very ffmpeg-wrapped), etc. I’ve had much smoother experiences with Sony Vegas in the early 10’s. It didn’t crash, had much better frame-by-frame and speed manipulation, and effects stacked more naturally. I do prefer using a FOSS variant, though, even given the discomfort.

Lastly

Let’s talk about the bigger picture outside the individual tools used.

What would you do differently?

Many things. I’d get a better UI scaling system from the outset. I’d want to set up some asset pipelines before going, with more nodes that actually fit more towards Godot’s philosophy of working. I’d change my release windows to better suit player sentiment, and one of the more important things is that I will most likely kill the next game that I’m targeting for bigger audiences faster if it doesn’t seem good enough. I’ve committed to finishing this one, really just to get through the motions of things, but I’d like to be more wise about that with developing upcoming ones. This one was set up as an educational experience from start to finish, and it has been wildly successful in that regard so far.

Conclusion

Talking with Marcel and playing his latest game gives a clear idea of how mature open source has become. It feels like a miracle that today you can make a professional game using nothing but free and open source software tools.

It is not to a state where every triple-A game can be made with it, and there is a good business reason to still pay for closed software tools, but it is not the only solution anymore.

Modern License Metadata for Python Packages: An Introduction to PEP 639 and SPDX

Tom Nijhof — Mon, 10 Nov 2025 14:59:08 +0000

As a developer working extensively on license_scanner, I've encountered numerous Python packages with outdated license metadata. Understanding PEP 639 is crucial, as it introduces significant changes to how licenses are managed in Python packages.

Key Changes in PEP 639

Python now adheres to the SPDX (Software Package Data Exchange) standard, moving away from using classifiers. The recommended approach is to use only two fields in your pyproject.toml file: license and license_files.

license: This field should be a string.
license_files: This field can be a string or a list of strings.

Choosing the Right License

There are numerous licenses available, many with similar names. For example, if a package is published under the "BSD License," it could refer to any of over 30 different BSD licenses, each with varying requirements. To avoid confusion, use a license name from the SPDX list, which you can find here: SPDX Licenses.

Here is an example of how the black package (version 25.9.0) uses this new standard: black's pyproject.toml.

Including License Files

Including the full text of the license in your package can be beneficial. You can do this by adding the paths to the licenses in the license_files field. Multiple files can be included if necessary. For example, see how numpy handles this: numpy's pyproject.toml.

Using Multiple Licenses

If you need to use multiple licenses for your package, use SPDX names along with brackets, the OR operator, and the AND operator. The order of operations for SPDX is: brackets first, then the AND operator, and finally the OR operator.

For instance, if you have (Apache-2.0 OR BSD-3-Clause) AND PSF-2.0, it means you must always accept PSF-2.0, but you can combine it with either Apache-2.0 or BSD-3-Clause. Here is an example from the cryptography package (version 40.0): cryptography's setup.cfg.

Handling Exceptions

The WITH operator can be used to add exceptions to a license. For example, PyInstaller version 6.16.0 includes the following: "GPLv2-or-later with a special exception which allows to use PyInstaller to build and distribute non-free programs (including commercial ones)". This indicates that the GPLv2 does not apply to products made with PyInstaller. This exception is resolved at the highest level in the SPDX operator order. See the example here: PyInstaller's pyproject.toml.

By following these guidelines, you can ensure that your Python packages have clear and up-to-date license metadata, making it easier for users to understand and comply with your licensing terms.

Conclusion

Adopting modern license metadata practices for Python packages, as outlined in PEP 639 and the SPDX standard, is essential for maintaining clarity and compliance. By using the license and license_files fields in your pyproject.toml file, you can provide precise and understandable licensing information. Choosing the correct license from the SPDX list helps avoid confusion, while including full license texts and handling multiple licenses and exceptions ensures comprehensive coverage. These practices not only streamline the licensing process but also enhance transparency and trust among users and contributors.

Datalists or 50 lines of extra JavaScript and HTML?

Tom Nijhof — Wed, 29 May 2024 20:46:13 +0000

If you’re looking to incorporate an autocomplete feature into your text input fields, there are two options available: using datalist or writing some JavaScript. I experimented with both on my website to compare their pros and cons. The main difference are in my pull request 42.

This blog is part of caffeinecritics.com the code can be found on GitHub.

Datalists

With just a few lines of code, you can easily add autocomplete functionality to your input fields. The code is surprisingly simple and took me much more code to accomplish without it.

Code is not the product, it is the liability of the product.

    <input
      type="text"
      class="border-grey-light block w-full rounded border p-3"
      list="all-current-producers"
      v-model="producerName"
      @input="updateProducer()"
      />
    <datalist id="all-current-producers">
      <option v-for="producer in producers" :value="producer.name"></option>
    </datalist>

According to recent statistics, Datalist is supported by a whopping 97.5% of websites. However, there’s one notable exception — Firefox for Android, which does not support Datalist. However, it only has a market share of 0.3%. This minor setback can be particularly frustrating given that I use this browser personally. Additionally, some browsers offer integration with Datalist, such as Chrome for Android, which allows users to easily access and utilize the feature through the keyboard.

However, there is a drawback to using datalists. By default, the browser styles them, which means you have limited control over their appearance. While you can overwrite this by adding your own CSS, doing so requires extra effort and additional JavaScript code.

Own JavaScript

Our own JavaScript will improve across various platforms, including Firefox on Android. However, it’s worth noting that some browsers may lose their unique integration features. On the other hand, you’ll regain a significant amount of styling freedom. I must admit, I prefer the new look much more, but it requires additional effort to ensure seamless support for mobile browsers as well.

Conclusion

Datalists have some advantages and disadvantages. On the plus side, they offer less code and better integration with web browsers, making it easier to use them. However, there are also some drawbacks to consider. For instance, styling Datalists can be more challenging, and they’re not supported by Firefox on Android devices. Personally, I opted for Datalists because I prefer to keep my code simple.

Animation in SVG

Tom Nijhof — Sun, 21 Apr 2024 20:49:20 +0000

SVG (Scalable Vector graphics) is a versatile tool that allows us to create graphics with scalable vector shapes, such as lines and circles. The best part? These graphics can be scaled down to infinitesimal sizes without any loss of resolution! But wait, there’s more — we can even add animation to our SVG without needing to use CSS. This means that our graphics will come to life and capture the viewer’s attention in a whole new way. Whether creating a simple logo or a complex info-graphic, SVG is a potent tool that can help you bring your visual ideas to life.

A button drawn with 3 circles in SVG

    <svg class="h-fit w-fit" width="102.635mm" height="102.635mm" viewBox="0 0 103 103" version="1.1" id="svg1"
       xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg">
       <circle style="fill:#4d4d4d;stroke:#000000;stroke-width:3.01567" cx="51.50901" cy="51.479477" r="49.80949"
           id="Casing" />
       <circle style="fill:#9b0101;fill-opacity:1;stroke:#6d0101;stroke-width:2.63;stroke-opacity:1" cx="51.50901"
           cy="51.479477" r="35.757164" id="back-button" />
       <circle style="fill:#ff0000;stroke:#6d0101;stroke-width:2.63;stroke-opacity:1" cx="61.425705" cy="50.430336"
           r="35.757164" id="front-button">
       </circle>
    </svg>

The SVG code for the button

Animation

Did you know that SVG has an animation element? With this, we can make things move or change over time on our websites or applications. Take a look at the example below, where I’m changing the center x position (cx) of a light red circle from 61 to 50 and back to 61. The animation will keep repeating forever!

    <svg class="h-fit w-fit" width="102.635mm" height="102.635mm" viewBox="0 0 103 103" version="1.1" id="svg1"
       xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg">


       <circle style="fill:#4d4d4d;stroke:#000000;stroke-width:3.01567" cx="51.50901" cy="51.479477" r="49.80949"
           id="Casing" />
       <circle style="fill:#9b0101;fill-opacity:1;stroke:#6d0101;stroke-width:2.63;stroke-opacity:1" cx="51.50901"
           cy="51.479477" r="35.757164" id="back-button" />
       <circle style="fill:#ff0000;stroke:#6d0101;stroke-width:2.63;stroke-opacity:1" cx="61.425705" cy="50.430336"
           r="35.757164" id="front-button">
           <animate ref="animateRef" attributeName="cx" values="61.425705;50.430336;61.425705"
               dur="1s" />
       </circle>
    </svg>

Trigger on click

To finish off let’s only trigger the animation if we click. The example below is done with VUE, to see a vanilla JavaScript example see this stackoverflow example.

When we change an animation element’s repeatCount to 1 and begin to indefinite, it stops completely. Then, we add a function that starts the animation again by using a click event. Inside this function, we get the animation element either by reference (VUE.js) or by ID (vanilla JS), and call the beginElement method to start the animation once.

Example: https://escapethisgamevue.github.io/

    <script setup lang="ts">
      import { ref } from "vue"


      const animateRef = ref<any>()
      function clickButton() {
         animateRef.value?.beginElement();
      }
    </script>

    <template>
       <div class="h-fit w-fit" @click="clickButton()">
           <svg class="h-fit w-fit" width="102.635mm" height="102.635mm" viewBox="0 0 103 103" version="1.1" id="svg1"
               xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg">
               <circle style="fill:#4d4d4d;stroke:#000000;stroke-width:3.01567" cx="51.50901" cy="51.479477" r="49.80949"
                   id="Casing" />
               <circle style="fill:#9b0101;fill-opacity:1;stroke:#6d0101;stroke-width:2.63;stroke-opacity:1" cx="51.50901"
                   cy="51.479477" r="35.757164" id="back-button" />
               <circle style="fill:#ff0000;stroke:#6d0101;stroke-width:2.63;stroke-opacity:1" cx="61.425705" cy="50.430336"
                   r="35.757164" id="front-button">
                   <animate ref="animateRef" attributeName="cx" begin="indefinite" values="61.425705;50.430336;61.425705"
                       dur="1s" repeatCount="1" />
               </circle>
           </svg>
       </div>
    </template>

Conclusion

Animations in SVG format can be quite impressive and easy to use without requiring additional coding like CSS or JavaScript. This means that creating scalable vector animations is often possible without needing to rely on these tools.

Boy Scout refactoring works but can take 189 years (still faster than waiting for motivation)

Tom Nijhof — Mon, 25 Mar 2024 21:34:33 +0000

The Boy Scout principle, “Leave a place better than you found it,” is an admirable philosophy that can be applied to many aspects of life, including coding. Refactoring a large code base with this principle in mind can be a challenging task, but it’s certainly possible. Can you replace one language with another? Well, I wondered about this and I found a use case where this happened — the Dutch Law.

What is Boy Scout refactoring?

The Boy Scout principle is to leave a place better than you found it. This can be cleaning up, adding something, or updating something. In code, we use this as an excuse to refactor every piece of code we have to work on.

A great upside is that you never plan time to refactor. You also never spend time on just refactoring. And in general, it costs less time, because if you already worked on the code the refactoring will go faster.

However, not all code gets updates at a similar rate. Some code will be updated every sprint, other code will never be updated after it is written. So what if a standard changes before you update the last code? Well, now you have 3 standards, good luck!

The Dutch Law

Let’s go over a bit of history, in 1813 the Netherlands broke free from France (again). This is the point where the current Dutch law can be traced back to. This is not the beginning of the Netherlands, but the beginning of the current Dutch law (let’s ignore the rest of the messy history).

The Dutch made an important decision, “we keep all the France laws we have from when we were puppet state and rewrite them in Dutch when we update them”. So basically Boy Scout Refactoring.
And so they did, every time a law needed an update it would be rewritten in Dutch. It took till the 31st of October 2002 when the last law was rewritten! 189 years! (link)
For those wondering, the last law is *Loi concernant les Mines, les Minières et les Carrières; *Something about mining.

What happened in these years? Well:

Belgium broke away from the Netherlands.
Luxembourg and the Netherlands stopped sharing a head of state because a Dutch succession law allowed for a woman and Luxembourg did not.
World War One happened. This left Keizer Willem in the Netherlands until the German monarchy will be restored (his grave is still here) (link).
World War two, when the Nazis introduced more laws into the Netherlands. (link)
Indonesia became independent followed by Suriname
The European Union was founded (now we have laws in France, Dutch and 22 other languages). (source)
I was born (maybe a slightly smaller event compared to the rest)

Conclusion

When it comes to refactoring, the Boy Scout approach is not a substitute for more comprehensive techniques. While the Boy Scout principle can be a useful tool in certain situations, it’s important to recognize that it’s not a one-size-fits-all solution. In order to effectively refactor code, it’s important to use a variety of techniques and approaches, rather than relying solely on the Boy Scout method. By incorporating different strategies into your refactoring toolkit, you can ensure that your code is always well-structured, maintainable, and efficient.

The weird quirk with rounding in Python (and that is good)

Tom Nijhof — Wed, 20 Mar 2024 19:43:01 +0000

When working with rounding in Python, you may have come across an unexpected quirk. Unlike most people who tend to round numbers ending in .5 up, Python operates differently. While it rounds 0.5 to 0, it rounds 1.5 to 2, following the international standard (IEEE 754). This may be seen as a feature or a bug, depending on how you view it.

It is a bug, for me!

If you encounter a bug when working with numbers ending in .5 I recommend utilizing the build library decimal. Within this library, there is a function that rounds all numbers ending with .5 up by using the ROUND_HALF_UP mode. This mode can be found in the documentation, along with other options for rounding. By incorporating this function into our code, we can ensure that any numbers ending in .5 are rounded correctly and avoid potential bugs.

I do NOT recommend using this unless it specifically causes a bug!

    from decimal import Decimal as D, ROUND_HALF_UP


    def round_nat(d):
        """
        Rounds all halves up
        """
        return D(d).quantize(D('1'), ROUND_HALF_UP)


    for x in range(1,100):
        d = x/10
        print(f"{d} rounds to {round_nat(d)}")

It is a feature!

Rounding behavior in Python conforms to IEEE 754 rounding to nearest, ties to even. This is also known as bankers rounding or Dutch rounding. Guido van Rossum is not a banker but he is Dutch.
This ensures a fully random number is just as likely to round up as down. For example, let’s consider a range of numbers from 0 to 10 in increments of 0.1. If we calculate the average of these numbers, it comes out to 4.95. However, if we use the round_nat function (created in the previous chapter), we get an average of 5, due to the presence of 10 numbers ending in .5, which are all rounded up. This results in a slight bias towards a larger number. On the other hand, using native Python rounding eliminates this bias.

    all_num = [i/10 for i in range(0, 100)]
    print("average of all numbers:", sum(all_num)/len(all_num))
    all_rounded_num = [round(i) for i in all_num]
    print("average of all rounded numbers:", sum(all_rounded_num)/len(all_rounded_num))
    all_nat_rounded_num = [round_nat(i) for i in all_num]
    print("average of all natural rounded numbers:", sum(all_nat_rounded_num)/len(all_nat_rounded_num))

    average of all numbers: 4.95
    average of all rounded numbers: 4.95
    average of all natural rounded numbers: 5

Another way to understand it is by looking at the numbers between 0 and 1 with 1 decimal. We have 9 numbers in between, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9. To round them we need to remove 0.1 from 0.1, and add 0.1 to 0.9. Meaning their biases balance out.
The same for 0.2 and 0.8, 0.3 and 0.7, and 0.4 and 0.6; All numbers except 0.5. We do not have a counterbalance for 0.5 between 0 and 1.

To balance rounding 0.5 we balance it with 1.5. We remove 0.5 from 0.5 and add 0.5 to 1.5. Meaning that rounding is just as likely to increase as decrease a random number.

Conclusion

Rounding in Python may seem unusual at first glance, but it’s actually quite useful. Understanding how it works is essential as it can cause a program to behave differently than expected. While it may not have a significant impact in most cases, it’s important to be aware of this behavior to avoid any potential issues.

How to not launch an empty app

Tom Nijhof — Tue, 19 Mar 2024 20:46:55 +0000

Many applications are currently displaying content in various forms. Reddit, Facebook, Masterdom, Yelp, and CaffeineCritics are just a few examples of apps that offer content in one way or another. While the technology behind these apps may not be particularly groundbreaking, it is the content they provide that truly gives them value. However, a question remains: how can app developers fill their new apps with content without violating copyright laws?

Just make it

If you need content, it's worth investing the time to create it. A great example is Artturi Jalli, who developed an app for finding Finnish cottages. He dedicates a significant amount of time to writing blog posts to promote his web app. Please note that this article tells us he spent 6 hours coding and more than 1000 hours of blogging.

https://medium.com/@artturi-jalli/i-built-an-app-in-6-hours-that-makes-1-500-mo-85139edee87d

Generate it

Using artificial intelligence to create content may seem like a dream come true, but it's not as simple as it sounds. While AI can certainly assist in the creation process, you are still ultimately responsible for ensuring the quality of the content. Moreover, users are becoming increasingly aware of AI-generated content, so it's important to approach this method with a mindset of "make it yourself with the help of AI" rather than relying solely on machine-generated output.

Scrape

Data scraping can be a useful tool for collecting information from various websites. In my case, I utilized this technique to gather data on coffee and tea offerings from numerous webshops. By scraping data from these sites, I was able to accumulate a sizable collection of drinks without requiring users to manually input reviews. This approach not only saves time but also makes the app feel more dynamic and alive! However, it's crucial to be mindful of copyright considerations when engaging in data scraping.
At Mastodon, you also see this a lot in the form of twitter-bots (or x-bots I guess). They copy tweets and toot them on Mastodon. However, this might* be copyright infringement, so it may not be the best if you are a business.
*might be because there are thousands of governing bodies that make laws. Ask a lawyer, not a blog post if you have questions about it.

Wait for users

In the world of app development, it's (sometimes) possible to launch an app without any users and wait for them to fill it. This approach is often used by online games that become more enjoyable with more players. However, by incorporating NPCs (non-player characters) and storylines for solo play, developers can create an engaging experience without the need for others.
Apple has taken this approach with their new VR headset (that they do not want to call VR headset), which comes with a few basic apps and has ported many iPhone apps to work in the VR environment. While the initial value may come from Apple itself, the true potential lies in the creativity of other developers who will bring innovative apps to the platform. However, if not enough people will make Apple VR apps the project will be killed.

Conclusion

In conclusion, filling mobile apps with engaging content while respecting copyright laws requires a careful balance of strategies. While shortcuts like AI-generated content or data scraping may seem appealing, prioritizing original creation, as seen in examples like Artturi Jalli's Finnish cottages app, can lead to greater user satisfaction.

Why SHOULD Python be your first language?

Tom Nijhof — Fri, 16 Feb 2024 21:08:52 +0000

While reading an article by Krishnaa on why Python shouldn't be one's first programming language, I found myself disagreeing with many of the points presented. In fact, most of the arguments seemed to suggest that Python is actually a great choice for beginners. It was an interesting read, but I couldn't help writing this response.

Why should Python not be your first language?

krishnaa192 ・ Feb 14

#python #datastructures #java #coding

What makes a good first language?

In my view, a good first language should be welcoming and make it easy for beginners to learn programming without encountering numerous obstacles or feeling discouraged. A language that requires new programmers to master numerous "real" programming concepts from the start can be off-putting and may lead to frustration. Conversely, a language like Python is ideal for beginners due to its simplicity and ease of use, allowing them to learn without feeling overwhelmed. By making programming more accessible and enjoyable, we can encourage more people to take an interest in this field and foster a positive learning environment.

Data Type Declarations

In Python, we use a dynamically typed system, which means that you don't have to worry about assigning the wrong data type to a variable. For instance, you can simply add a double to an integer or divide it by a float without any issues. This is beneficial for beginners as they can postpone learning about different types of numbers until they feel more comfortable with programming. For example, let's say we have a variable x that is initially set to 4.5. We can then assign it the value of 10, which might seem strange at first. However, Python will automatically convert the value to a float without any errors. This process feels natural and intuitive, allowing beginners to focus on learning programming concepts without getting bogged down by technical details. Once you're ready to introduce types, you can add type hints to your code without having to learn an entirely new language. This makes the learning process more incremental and manageable. By gradually introducing new concepts, you can build a strong foundation in programming that will serve you well in your future endeavors.

Limited data structure

In a recent blog post, we explore Vanilla Python regarding data structures. Unlike many other programming languages, Vanilla Python only provides lists, with no arrays to be found. At first, this might seem like a limitation, but it actually works in the language's favor. By not having arrays, beginners are spared the confusion of distinguishing between lists and arrays, as there is only one type of data structure available. This streamlined approach allows learners to focus on other aspects of programming without getting bogged down in the details of multiple data structures. Once they have a solid foundation in Vanilla Python, they can then explore additional packages like NumPy, which provide array functionality. This gradual learning process makes it easier for beginners to absorb new concepts and build upon their existing knowledge.

Less Exposure to Low-Level Concepts

“Python abstracts many low-level details, making it easy for beginners to start coding without understanding some fundamental concepts such as memory management or pointers.” - Krishnaa

I could not have said it better myself. Memory optimization is not for beginners, it is what you learn to do from beginner to mid-level.

Good Built-in Functions

In Python, there are useful built-in functions that can help beginners get started with ease. For instance, the sort function is a great tool for organizing data in a logical manner. However, forcing a beginner to learn a specific sorting algorithm may hinder their enjoyment of the language. If they show interest, it's fine to explain the concept, but it's not essential knowledge for basic use cases.

Downsides of Python as a first language

I have talked a lot about why Python is great for beginners, but let's also address some of the shortcomings.

Hard to install

Getting Python set up and running can be a bit of a challenge. Many tutorials focus on creating the ideal work environment, but we're here to show you a faster way. If you're learning Python, check out Mu. It's easy to install and get started, just like Processing for Java.

Boring visuals

In our pursuit of creating engaging and interactive programs, visual feedback plays a crucial role in keeping users motivated. While programming can become challenging at times, it's essential to provide visually appealing results to keep things interesting. For Python developers, utilizing libraries like PyGame can help create more visually stimulating content, even if the language itself may not be ideal for game development. To gain further inspiration, checking out the Mu tutorials can offer valuable insights.

Conclusion

The simplification of Python is what makes it a great first language! Do not try to punish beginners because they do not know everything, help them by letting them skip the more advanced topics.

Caffeine Critics: January update

Tom Nijhof — Wed, 14 Feb 2024 14:40:56 +0000

Several small changes were made to the Caffeine Critics project within the past month. To gather all these updates in one place, I have decided to share them here. So, here are the updates for Caffeine Critics within January.

UX: Using stars for rating

With vue-star-rating, you can easily add a rating system to your project. The rating can now be rounded off to half stars for more precision. Clicking directly on the stars is simple, but there are also plus and minus buttons located next to them for added convenience when using a mobile device or the user has trouble with the mouse.

In the database, the rating will be stored as a value between 0 and 240. This allows for some flexibility in adjusting the rating system. For instance, 240 can be divided by the numbers 2, 3, 4, 5, 6, 8, 10, 12, 15, 16, 30, 40, 48, 60, 80, and 120, which means that I can swap the current 10-step rating system for a 48-step by simply altering the front-end without affecting the database.

UX: Clear error message

When logging in, registering, or creating a new drink, you could encounter an error. In the past, this error was silent and went unnoticed, but with the integration of vue-toast-notification, users are now provided with clear messages.
I think this lack of clear messages resulted in my first user disappearing, as their account was created but never verified, making the app seem non-functional for them.
However, we can learn from this experience and strive to provide a better experience for future users.

New feature: Filter on producer

With the addition of a new filter, searching for drinks on our platform has become even more convenient. Now, you can specifically search for drinks produced by "Albert Heijn", making it easier to find the one you want to review

Bugfix: Github page + VUE.js = 404 for some files

Github Pages rely on Jekyll, which in turn uses _ as a default ignore pattern for files. However, this caused an issue when vue-star-rating was introduced, because it created a file named _plugin-vue_export-helper-*.js during the build process. Fortunately, the solution was straightforward - creating an empty file called .nojekyll in the public folder resolved the problem. The amount of time spent searching for this simple fix will not be mentioned…

UX: Populate database

An app launching with nothing in it will never succeed. Users can't do all the work, so I try to gather drinks from different producers to make it more user-friendly. Instead of covering multiple markets partially, my goal is to collect all teas and coffees sold in the Netherlands' big supermarket chains and add producers I come across. At the end of January, there were 555 total drinks.

The producers added in January

Pickwick
Clipper
Albert Heijn
Zonnatura
Lipton
Pukka
Bellarom (Lidl brand)
Bean Brothers
Uno a basta

Conclusion

The app is maturing rapidly, but unfortunately, no one is sticking around to use it. Our next goal is to scrape all tea and coffee products in Dutch supermarkets and make sure drinks and producers are fully CURD (create, update, read, and delete) for maximum efficiency.

Sharing code between projects

Tom Nijhof — Sun, 11 Feb 2024 12:02:18 +0000

As developers, we often strive to follow the principle of "Don't Repeat Yourself" (DRY) in our code. While this practice can lead to more maintainable and efficient software, it's not always a straightforward task. In my experience, I've found that several techniques can help us avoid repetition and write better code. I'd like to share some of these methods with you today.

Just repeat yourself

When it comes to implementing a new feature in your project, sometimes the simplest approach is the best. In these cases, simply copying and pasting the code from one project to another can be the most efficient method. This approach works particularly well when you expect the two pieces of code to differ significantly from each other. By repeating yourself in this way, you can save time and effort compared to trying to rewrite the code from scratch.

Pros:
Very easy to implement

If the use cases start to differ from each other it is easy to update the functions Cons:
You will have to maintain the same code in multiple places

Create a package

Creating a package and sharing it in a distribution is one of the most common ways to share code. If you are working on open source I would say this comes with barely any downsides. However, if you need to work on closed-sourced software you first need to set up your own distribution in order to make this work.
Most developers have already worked with packages so working with your code as a package will be easy to adopt.

Pros:

Almost every developer will be able to work with it The versioning of code is easy Cons:
Setting up an internal distribution for closed-sourced software
Additional boilerplate code to turn your work into a package.

Git submodules

If you're using Git for your source control, you can utilize Git submodules to add another repository as a folder within your current repository. This allows you to access the full repository of your project. To add a submodule, use git submodule add [URL2GITREPO].
When cloning a repo for the first time with a submodule, you'll need to run git submodule update --init --recursive to populate the submodule, otherwise, it will simply be an empty folder. The submodule will keep track of what commit and branch it is on.
However, in my experience, this solution can be less stable and requires more debugging. Additionally, you may need to explain it to colleagues since it's not a common practice.

Pros:

Lots of control of which version No additional infrastructure is needed besides git Cons:
It does not always work well, and to debug it you need some good git knowledge
Who receives does need read access to your code to make it work
Only works for code, not for compiled binaries
All tests and developers' code will also be in the repo
You need to pull the latest version of the submodule to make sure you are in sync

An example of ai-writer-assistant.github.io added as a submodule to a project

Conclusion

There are multiple solutions for sharing code, and none of them are the best solution every time. Make sure you understand your situation and realize what will give you the least work in the future.

Locally hosted AI writing assistant

Tom Nijhof — Sat, 10 Feb 2024 14:10:53 +0000

Most artificial intelligence (AI) tools are either closed-source or require a server to function. However, with the help of Ollama, it is possible to create simple yet powerful local AI tools without any of these constraints. In this blog post, I will demonstrate how I built my own local AI tool using Ollama's user-friendly interface and flexible architecture. By doing so, I aim to showcase the ease with which one can leverage AI capabilities without relying on proprietary software or remote servers.

An AI image of a bird robot writing

I recently developed an AI-powered writing assistant using Ollama. To build this innovative tool, I leveraged Vue.js and the Ollama JavaScript package, both of which proved to be indispensable in the development process. By harnessing the power of these advanced technologies, I was able to create a user-friendly interface that streamlines the writing process and yields high-quality content with ease.

The solution only works on Linux, Windows Subsystem Linux (WSL), and maybe Mac

A screenshot of AI writer showing how the first draft of this blog was made.

Integrate into JavaScript

Ollama will send the message to Llama2 model. The response can be returned with streaming, allowing for a seamless and interactive experience. By displaying the model's response in real-time, users will no longer have to look at loading bars, further enhancing their overall experience. This feature not only simplifies the programming process but also provides a more dynamic and engaging environment for all involved.
It will use a model named blog that I create in the next chapter.



const output = ref(“”)
async function sendToModel(message: String) {
// Empty the output
output.value = ""


// Send the message to Ollama
// It will use the model named ‘blog’
 const response = await ollama.chat({
   model: 'blog',
   messages: [{ role: 'user', content:message }],
   stream: true
 })


// At every part of the stream back to the response in real time
 for await (const part of response) {
   output.value += part.message.content
 }
}

Fine-tuning the model

Ollama's default model is Llama2, which is suitable for casual conversations. However, I wanted to modify it to generate rewritten versions of my initial ideas. To achieve this, I created a custom model file and made two key adjustments. Firstly, I lowered the temperature to 0.5, which results in less creative output that still conveys my intended message. Secondly, I modified the system message to avoid generating answers and instead focus on rewriting the input text. Below is the updated model file for your reference.



FROM llama2

# set the temperature to 1 [higher is more creative, lower is more coherent]
PARAMETER temperature 0.5

# set the system message
SYSTEM """
Rewrite the following into a paragraph of a technical blog with simple and formal English.
"""

To utilize the newly introduced model file, I executed the following command. This resulted in the generation of a freshly minted model named "blog." With this novel model at my disposal, I am now able to incorporate it into my JavaScript applications for seamless usage.
ollama create blog -f ./Modelfile

Conclusion

In conclusion, Ollama provides an accessible and user-friendly means of utilizing Large Language Models (LLMs) in local projects. The platform allows for seamless customization to meet individual needs and preferences, making it a valuable tool for those looking to leverage the power of LLMs in their projects. By providing an easy-to-use interface and a wide range of customization options, Ollama simplifies the process of incorporating LLMs into local projects, enabling users to unlock their full potential.

Medical Subject Headings (MeSH) Into Neo4j

Tom Nijhof — Wed, 07 Feb 2024 07:49:09 +0000

To make a knowledge graph, it is useful to have a vocabulary in place, which is called an ontology.

The Medical Subject Headings is one such ontology, which includes many of the medical terms that are currently being used.
It can be downloaded as an RDF file (N-triples), making it easy to import to Neo4j with neosemantics (n10s).

Installing n10s in neo4j desktop

The next three commands will import the 2021 MeSH graph directly into Neo4j. It will take a moment before all 2 million nodes and 4 million relations are loaded in.

    CREATE CONSTRAINT n10s_unique_uri ON (r:Resource) ASSERT r.uri IS UNIQUE;
    CALL n10s.graphconfig.init();
    CALL n10s.rdf.import.fetch("https://nlmpubs.nlm.nih.gov/projects/mesh/rdf/2021/mesh2021.nt","N-Triples");

Exploring the Data

Before I start, I will set the caption to rdfs_label for resources, so the nodes have a name. For ns0_Term, I will use ns0_prefLabel.

Naming nodes within Neo4j desktop

Let's start with the sexiest thing to do — reading the documentation of RDF data structure of medical terms used to sort medical papers.
Did I say “sexy”? I meant nerdiest.

I will not go over the full structure; instead, I will select just two elements I think are interesting to start with. Feel free to disagree.

The code snippets in this blog are cypher query you can use in Neo4j. It is not needed but might be useful if you want to know how I got the results, or they can serve as an example that my cypher is not optimized, up to standard, etc.

Terms, Descriptors, and Concepts

Descriptors, concepts, and terms are very closely related. Descriptors are the broadest — within descriptors, you have concepts (at least one that is the preferred one). Concepts have terms — these terms hold synonyms for the concepts. Each concept has one preferred term, while the descriptor also has one preferred term out of all (see picture below).

    MATCH (q:ns0__Term)<-[]-(n:ns0__TopicalDescriptor)-[]->(p:ns0__Concept)-[]->(z:ns0__Term) 
WHERE (n.rdfs__label = "Calcimycin")  
return n, p, q, z

Relation between descriptor (pink), concepts (green), and terms (blue)

Terms are very useful for labeling text. Concepts can define a part that is smaller than the whole descriptor. The descriptor holds the connection to the rest of the graph (tree, other descriptors, SCR, Qualifiers, etc.). I will mainly focus on the descriptors for graph algorithms.

Tree Structure

All TopicalDescriptor have a link to a tree-number (ns0_treeNumber) and to another TopicalDescriptor (ns0_broaderDescriptor).

These two hold very similar information but have one use case where they differ: multiple tree locations.

A descriptor can be in more than one tree at the same time (like the descriptor “eye”). Eye has tree number **A01.456.505.420 **as a subcategory of face, and **A09.371 **as a subcategory of Sense Organ. This can give us problems because these two tree numbers do NOT have the same subcategories!

Eyebrows are part of the eye as part of the face but are NOT part of the eye as part of a sense organ.

Tree overview of Eye in online MeSH Browser

If we use ns0__broaderDescriptor to go back from Eyebrows to the broadest description, we come upon a mistake. The broader description of Eyebrows is Eye, which has two broader descriptions (namely, sense organs and face). As Eyebrows is not a sense organ, this shouldn’t be correct.

    MATCH (n:ns0__TopicalDescriptor)-[:ns0__broaderDescriptor*]->(p:ns0__TopicalDescriptor) 
WHERE n.rdfs__label = "Eyebrows" 
return n, p

Sense Organs is found as broader description of Eyebrows

The other way is to go via the tree numbers. This will mean Eyebrows is only connected to one of the two tree numbers of Eye and does NOT have Sense organs as a broader description.

    MATCH (n:ns0__TopicalDescriptor)-[:ns0__treeNumber]->(t:ns0__TreeNumber)-[:ns0__parentTreeNumber*]->(p:ns0__TreeNumber)<-[:ns0__treeNumber]-(d:ns0__TopicalDescriptor) 
WHERE n.rdfs__label = "Eyebrows" 
return n, t, p, d

Going via the tree number gives only “Body Regions” and “Integumentary System” as the broadest descriptor

For this reason, I will use ns0_treeNumber to find hierarchical relationships rather than ns0_broaderDescriptor.

Conclusion

In conclusion, using the Medical Subject Headings (MeSH) ontology to create a knowledge graph is highly beneficial. By importing MeSH as an RDF file into Neo4j with neosemantics (n10s), we can easily explore the extensive collection of medical terms and their relationships.

Descriptors, concepts, and terms are essential components of MeSH. Descriptors encompass broad categories, concepts provide specific definitions within descriptors, and terms offer synonyms for concepts. Understanding the hierarchical structure is crucial for effective graph analysis, with tree numbers being a more reliable way to establish relationships than broader descriptors.

In summary, MeSH is a valuable resource for constructing medical knowledge graphs. Leveraging its rich information and employing appropriate graph analysis techniques, researchers can gain meaningful insights from medical literature and data.