Stephen Smith's Blog

Musings on Machine Learning…

Koch Snowflake in Applesoft Basic

leave a comment »


After learning to program in high school in BASIC on a PDP-11, I went to University where first year computer science was taught using WATFIV (Waterloo Fortran IV), where we had to write our programs by hand, type them into an IBM card punch machine and then submit our stack of punch cards to the data center to run. Later we would receive back our punch cards along with any printout from the program.

Definitely a step backwards from the interactive programming on the PDP-11. I joined the co-op program and after my first work term, used much of the money I made to buy an Apple II+ computer. This returned me to BASIC programming with Applesoft BASIC, which was created by Microsoft for Apple to replace their original Integer Basic.

Last time I produced a Koch Snowflake in QB64, a version of BASIC more advanced than the early BASICs like on the PDP-11 or Apple II. QB64 had functions, subroutines, structured programming and line numbers were optional. I wondered about producing the same program on a more original version of BASIC.  Applesoft is a good candidate as it uses line numbers, has no structured programming, but it does have a handful of builtin graphics commands that allow us to write our Koch Snowflake program. The main challenge is what to do about the recursive function calls.

Apple II Emulators

Although I sold my Apple II+ many years ago, to buy an IBM AT clone, it turns out many people have put a lot of effort into writing Apple II emulators and that you can find an Apple II emulator on most systems, In this case I used the AppleWin emulator, which was easy to install and up and running in no time. Below is the Koch Snowflake on the Apple screen. This is in the Apple II’s high resolution graphics mode of 280×192 in 6 colors. Rather low res by today’s standards.

Applesoft BASIC programs aren’t stored on the disk as regular text files, they are stored in a tokenized format which helps the interpreter run them faster. This is a problem as you can’t easily transfer the files back and forth to a PC. Since the program is small, I just typed it into the Apple, but it means to show the listing you get the following screen shots rather than text in the article.

The big innovation of Applesoft BASIC is that variables are floating point by default rather than integer, so this works well for the couple of calculations we need to do. The other thing is that variable names can be longer, but only the first two characters are used for uniqueness, hence AB = ABC = ABCD. The program roughly follows the same logic as the program in the last article, except no functions and recursion is handled by a simple stack stored in a couple of arrays.

The Program

The first part of the program initializes the variables, defines the arrays that will be used to stack level and line length and sets the graphics mode and color (white = 3).

The next part corresponds to the KochSnowflake subroutine in the last article that draws the main three sides of the snowflake.

Lines 200 to 330 correspond to the SnowflakeSide subroutine, note the lack of structured programming forces us to have four IF statements.

Lines 1000 to 1060 are the turtle graphics routine. We don’t have a turn routine, as the angle is a global variable. Move is similar to the Move Subroutine in the last article.

All in all, still quite a simple program. Editing programs in Applesoft is quite old school, but the memory of how to do things returns fairly quickly. Still people who’ve only used graphics editors might find it baffling.


It’s great that people have put so much effort into creating such high quality emulators of historical computer systems. This was a nice journey back down memory lane of how I did most of my programming in University from second year onwards. The Apple emulators support Apple’s Pascal system and even the add-on Z80 CPM cards. Perhaps I wouldn’t want to produce modern commercial software this way, but I think there are lessons to be learned from learning some of the old ways.

Written by smist08

September 17, 2022 at 9:48 am

Back to Basics

with 2 comments


I originally learned to program in grade 10, where my highschool had a DEC LA36 DECwriter terminal connected through a 300 baud modem to a local college’s DEC PDP-11 running the RSTS-11 operating system. We wrote programs in the built-in BASIC programming language. This was 1976 back before structured programming took off where programs had line numbers and you used GOTO statements all over the place. The advantage of BASIC is that it is simple to learn and the students at our high school picked it up pretty quickly. We wrote programs to perform scientific calculations and wrote all sorts of games. Programming back then was a lot of fun. I’ve blogged about quite a few programming languages, including Python, Fortran, Assembly Language, Erlang, Julia, Scratch, Processing, and C. I was just remembering BASIC and wondered about playing around with that. In my career I worked quite a bit with Microsoft’s Visual Basic, but wanted something more old school and open source. Similarly VB.Net is just C# without the semi-colons. After a bit of research, I found there are dozens of implementations of BASIC floating around. Some require line numbers, some contain structured programming, some are interpreters, some are compilers. I may survey some of these in a later blog, but as an example I thought I’d play with QB64 abit which is a compiler implementation of QBasic/QuickBasic. This implementation runs on Windows, Linux and MacOS, but as a compiler I think it only emits Intel/AMD assembly code. I ran this on Ubuntu Linux 22.04 on my laptop.

Koch Snowflake Yet Again

I use drawing the Koch Snowflake as a good example, as it’s a simple program, does something nice, but is long enough to demonstrate a few things of the language. QB64 has lots of built in graphics commands, so why not. The full listing is at the end of the article.

QB64 comes with a character based IDE which is good enough for basic development. Of course the source files are text files, so you can edit them in any editor you prefer. I was worried about the implementation, as I usually use recursion and wasn’t sure if this would be supported, but it turned out this wasn’t a problem. QB64 could easily handle the task and the program is actually fairly compact.

Notes on QB64

  • Installation: I installed QB64 on Ubuntu Linux, the Linux version of QB64 has a shell script which installs all the dependent packages along with the QB64 program. The script seems to know about quite a few flavors of Linux, but I can only attest to it running well on Debian based distributions.
  • Global Variables: I was expecting any variables to be defined or used outside a sub or function to be global, however this isn’t the case you have to “DIM SHARED” any variables you want to be global.
  • Variable Types: By default variables are single precision floating point. If you need them to be something else then you can use a “DIM” statement or there are a number of special characters that when placed on the end of a variable specify the type. Hence the & at the end of WHITE& tells QB64 this is a long integer. If you leave this off the program won’t work as the value produced by _RGB32(255, 255, 255) doesn’t fit in a floating point variable.
  • Line Numbers: This is a newer flavor of Basic with structured programming and hence no line numbers. You can always add labels and GOTO statements if you want to.
  • There is a JavaScript version of the compiler that emits JavaScript code, but it didn’t work on this program, generating JavaScript with a syntax error which I think was to do with the recursion. However, playing with QB in the JavaScript sandbox is fun.


QB64 is fun to play with. It’s not as old as the RSTS-11 Basic I learned in school and is a bit newer than the AppleSoft Basic I played with on my old Apple II+. If you worked with either QuickBasic or GWBasic on MS-DOS then this will be familiar, including the character based IDE.

In education, kids seem to start programming in Scratch and then progress to programming in Python. I wonder if there is room for Basic in-between as something more substantial than Scratch but without the complexity of the modern Python language. You can do a lot with Basic without the steep learning curve associated with more modern systems.

‘ Program to draw a Koch snowflake
_Title “Koch Snowflake”

STARTY = 130
LEVEL% = 3

DECLARE SUB KochSnowflake(level%)
DECLARE SUB SnowflakeSide(level%, size%)
DECLARE SUB move(dist%)

Dim Shared X, Y, angle, PI, WHITE&

WHITE& = _RGB32(255, 255, 255)
PI = 3.14159

Screen _NewImage(520, 520, 32)
KochSnowFlake (LEVEL%)

Sub SnowflakeSide (level%, size%)
    If level% = 0 Then
        move (size%)
        Call SnowflakeSide(level% – 1, size% / 3)
        turn (60)
        Call SnowflakeSide(level% – 1, size% / 3)
        turn (-120)
        Call SnowflakeSide(level% – 1, size% / 3)
        turn (60)
        Call SnowflakeSide(level% – 1, size% / 3)
    End If
End Sub

Sub KochSnowFlake (level%)
    turn (60)
    Call SnowflakeSide(level%, 400)
    turn (-120)
    Call SnowflakeSide(level%, 400)
    turn (-120)
    Call SnowflakeSide(level%, 400)
End Sub

Sub move (dist%)
    oldx = X
    oldy = Y
    X = X + dist% * Cos(angle * PI / 180)
    Y = Y + dist% * Sin(angle * PI / 180)
    Line (oldx, oldy)-(X, Y), WHITE&
End Sub

Sub turn (angle_increment)
    angle = angle + angle_increment
End Sub

Written by smist08

September 4, 2022 at 3:42 pm

Posted in programming

Tagged with , ,

Introducing the Raspberry Pi Pico W

leave a comment »


At the end of June, the Raspberry Pi foundation released a new version of the Raspberry Pi Pico that includes a wireless communications chip. This new Pico is named the Raspberry Pi Pico W and only costs $2 more than the base Pico. Basically, they added an Infineon CYW43439 chip which supports Wifi and Bluetooth, though only Wifi is supported through the SDK currently. Thus the Raspberry Pi Pico W is a true IoT (Internet of Things) chip, not requiring a physical connection to communicate.

Several other vendors have already added Wifi and Bluetooth in their independent RP2040 based boards. We reviewed the SeeedStudio Wio RP2040 here.


The hardware designers at Raspberry worked hard to add this wireless chip without affecting people’s existing applications. This meant they couldn’t use any of the exposed GPIO connectors. They also didn’t want to release a new version of the RP2040 chip, so they had to use a connection that was already exposed. The choice they made to minimize impact on people’s existing projects was to take over the connector that was previously used to control the Pico’s onboard LED. The reasoning being that flashing the onboard LED couldn’t be too important to people’s projects. You can still access the LED, but it is now wired to a pin on the CYW43439 chip and you need to go through the CYW43 device driver included in the Pico’s SDK. To blink the LED you need to initialize the high level driver:


Then you can set the LED high or low with:

    cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, led_state);

To make room for the new chip, a few things on the board have been moved around, notably the debug pins are now in the middle of the board rather than at the edge. When wiring the Pico W up, make sure you use the “Getting Started” guide for the Pico W, which contains the correct diagrams.

Programming the Pico W

The Pico W was added as the pico_w board type in the SDK. By default the RP2040 SDK will build for a regular Pico, so if you want wireless functionality you need to add “-DPICO_BOARD=pico_w” to your cmake command:

    cmake -DPICO_BOARD=pico_w -DCMAKE_BUILD_TYPE=Debug ..

Then pico_w.h from the boards/include/boards folder will be used and you have access to all the wireless features.

The documentation in the SDK is still a bit thin on the new features, but the SDK examples are a great source on how to do something, as working code is better than a dry API reference.

Wireless Interface

The Infineon CYW43439 uses an SPI interface to communicate with the RP2040. The RP2040 chip contains hardware to handle SPI communications; however, the Pico W cannot use these since they are connected to GPIO pins exposed externally. Raspberry didn’t want to reduce the number of GPIO pins, so instead they chose to use the programmable I/O processors (PIO)  to handle the communications. I imagine this will be a problem for anyone already using PIO in their projects as the program memory for PIO is only 32 instructions. There seems to be a #define in the SDK to use PIO for this, but I don’t see any support for not using this if you turn it off.

The CYW43 chip supports Bluetooth, but that support isn’t in the Pico’s SDK yet. There are already lots of examples of using various internet protocols to perform tasks like transmitting weather data to a web server to display on web pages. There is support for both C and MicroPython.

The source code for the CYW43 driver and any other aspects are all included with the SDK. Infineon has good documentation for their chip if you want to get into the details.

Pico H

Raspberry also officially released the Pico H and Pico WH which are just a Pico and Pico W with pre-soldered headers. If you are using a breadboard and want to save some soldering, I would recommend getting these versions.


It’s great to see Raspberry producing a version of the Pico with built-in wireless capability for true IoT applications. At this point the SDK is still being filled out, but there is plenty there to get you started. Too bad they couldn’t use the RP2040’s SPI hardware and instead use PIO for this, I enjoy using PIO and would rather it was left all for me. I predict the Raspberry Pi Pico WH will become the most popular Pico model.

Written by smist08

August 26, 2022 at 11:29 am

Assembly Language Tutorial Six for MagPi Magazine

with one comment

Assembly Language Tutorial Six for MagPi Magazine

I’m in the process of writing a series of Assembly Language tutorials for MagPi Magazine. The sixth and final one appeared in issue #121 on page 58.

The PDF version of the magazine is free to download, but MagPi always appreciates any donations.

This article doesn’t look at ARM Assembly Language, instead it looks at the special Assembly Language used by the Raspberry Pi Pico’s Programmable I/O processors. If a CPU needs to handle all the aspects of I/O operations itself, this can take a significant percentage of its processing power. To offload this I/O processing from the CPU, the RP2040 chip includes a set of special PIO coprocessors that can do the I/O processing independently from the CPU. This special Assembly Language is simpler than ARM Assembly Language and there is only room for 32 instructions in the coprocessor, but even so the RP2040’s PIO processor is powerful and can leave the RP2040’s main ARM CPU free to perform more application oriented processing.

Unfortunately this article was written before the Raspberry Pi Pico W was released. The Pico W adds Wifi and Bluetooth to the Raspberry Pi Pico. To do this, Raspberry took over the GPIO pin that connected the on-board LED to the CPU. As a result the program in this article won’t work on a Pico W, only the regular Pico. On the Pico W, the onboard LED is connected to the wireless chip and you have to go through the device driver for this chip to access the LED. There is an example program to do this in the Pico W’s SDK samples.

This tutorial can only give so much detail. If you want more detail, you can always consider my book RP2040 Assembly Language Programming.

Written by smist08

August 25, 2022 at 10:05 am

Rust Never Sleeps

leave a comment »


Rust is a relatively new programming language that first appeared in 2010. The purpose of Rust is to provide a systems programming language with the performance of C/C++ but without all the memory/pointer/multithreading/security problems. Version 6 of the Linux kernel will be adding support for writing modules in Rust and many companies have been writing their backend web servers in Rust.

I thought I’d have a look at programming in Rust and had a go on both a regular Raspberry Pi as well as with embedded Rust on the Raspberry Pi Pico. In this article we’ll look at a simple program to generate a Koch snowflake, a relatively simple program that still shows some of the features of Rust. The program listing is at the end of the article.

How to Create Graphics?

Rust doesn’t include a giant do everything runtime like C# has in .Net or Java has in the JRE. Instead people outside of the core language group have developed wrapper libraries of various commonly used systems. For GUI and graphics, I chose to use the wrapper for GTK3 as this seems to have good support and the included Cairo 2D drawing library is fairly good.

This works, but you can’t write GUI type design patterns like MVC in Rust because their memory management schemes are inherently unsafe or require garbage collection. Rust enforces the lifetime of every object and ensures there are no hanging references, this makes the sea of objects model most GUIs use where each object has references to a bunch of other objects illegal. Rust recommends alternate design patterns, but if you are wrapping an existing legacy library then you will have to work around a few issues.

Installing Rust and Required Libraries

Rust is easy to install, but it only installs Rust components. Any wrapped components need to be installed separately, in our case GTK3’s development components:

    sudo apt-get install libgtk-3-dev

Now we can install Rust, using rustup from their website: The current command to do this is:

    curl --proto '=https' --tlsv1.2 -sSf | sh

But best to copy the command from their website, in case it’s been updated. Then at the prompt select “1 – proceed with installation” to download and install Rust.

The installation adds a number of environment variables to the shell initialization scripts, to proceed you need to either restart a new terminal window or run:

    source "$HOME/.cargo/env"

Now we can create our Rust project, first creating a folder for our Rust projects and then using Rust’s cargo utility to create a project.

    mkdir rust
    cd rust
    cargo new fractal1 --bin --vcs none

The “–vcs none” part is to start cargo creating a github repository as well. We now have a working Rust program, which if we run with:

    cargo run

Will compile the simple program and print “Hello World”. The first time you run, the compilation takes a while since there are a number of system components that need to be compiled the first time.

To produce the Koch snowflake fractal, copy the Cargo.toml file at the bottom of this article over the one created by cargo and then copy the file over the created file in the src folder.

With these in place, type:

    cargo run

Then after everything compiles, the program should run and produce a window with the Koch snowflake at level 3.

Notes on the

The GTK3 wrapper is from I based the program on one of the examples in their Github repository. I found these examples to be the best source of information on the usage of this library as the documentation tends to be of a reference nature and doesn’t show how to put the parts together into a working program.

If you’ve seen any of my other blog articles where I created a Koch snowflake as an example, then you might wonder why I don’t store the Cairo drawing context in the TurtleGraphics struct rather than having it as a parameter to most method calls. The reason is Rust’s rules around avoiding dangling pointers, where you need to ensure the lifetime rules of every object. This means you can’t just store references in objects without guaranteeing their lifetime is less than the reference. In most practical cases this is difficult and the hoops to jump through are far worse than just passing it as a parameter. Not as object oriented perhaps, but on the other hand, no dangling pointers and no garbage collection.


Rust wants to replace C as a system programming language for projects such as the Linux kernel, web servers and even video games. Rust isn’t a simple language, it is large and some of its parts are quite complex. The safety rules to ensure that pointers are correct place a lot of limitations on what you can do as a programmer. The Rust parts of your program are safer than corresponding C programs, but with the state of things today, your Rust program will wrap a lot of components written in C/C++ that could be doing all sorts of bad things with pointers. The other limitation is that you can’t easily call Rust objects from other languages, limiting some interoperability scenarios.

I’m going to continue learning and playing with Rust. It has a number of appealing features, but I’m not sure if its complexity and strict enforcement of lifetime and ownership rules are too constraining.

Source Code Listings

The Cargo.toml file:

name = “fractal1”
version = “0.1.0”
edition = “2021”

# See more keys and their definitions at

gtk = “*”
gio = “*”
gdk = “*”
cairo = “*”

The follows:

use std::f64::consts::PI;
use gtk::prelude::*;
use gtk::DrawingArea;
use gtk::cairo::{Context};

const STARTX:f64 = 50.0;
const STARTY:f64 = 130.0;
const STARTANGLE:f64 = 0.0;
const LEVEL:i64 = 3;

fn build_ui(application: &gtk::Application) {
    drawable(application, 500, 500, |_, cr| {
        cr.set_source_rgb(0.0, 0.0, 0.0);
        cr.move_to(STARTX, STARTY);
        let tg = TurtleGraphics{x:STARTX, y:STARTY, angle:STARTANGLE};
        let mut kf = KochFlake{tg: tg};
        kf.koch_snowflake(cr, LEVEL);
        cr.stroke().expect(“Invalid cairo surface state”);

fn main() {
    let application = gtk::Application::new(

pub fn drawable<F>(application: &gtk::Application, width: i32, height: i32, draw_fn: F)
    F: Fn(&DrawingArea, &Context) -> Inhibit + ‘static,
    let window = gtk::ApplicationWindow::new(application);
    let drawing_area = Box::new(DrawingArea::new)();
    window.set_title(“Koch Snowflake”);
    window.set_default_size(width, height);

struct KochFlake
    tg: TurtleGraphics

impl KochFlake
    pub fn koch_snowflake(&mut self, cr:&Context, level:i64)
    { 60 );
        self.koch_snowflake_side(cr, level , 400); -120 );
        self.koch_snowflake_side(cr, level, 400); -120 );
        self.koch_snowflake_side(cr, level, 400);

    pub fn koch_snowflake_side(&mut self, cr:&Context, level:i64, size:i64)
        if level == 0
   cr, size );
            self.koch_snowflake_side( cr, level – 1, size / 3 );
   60 );
            self.koch_snowflake_side( cr, level-1, size / 3);
   -120 );
            self.koch_snowflake_side( cr, level-1, size / 3);
            self.koch_snowflake_side( cr, level-1, size / 3);


struct TurtleGraphics

impl TurtleGraphics
    pub fn move_dist(&mut self, cr:&Context, dist:i64)
        self.x = self.x + dist as f64 * f64::cos( self.angle * PI / 180.0);
        self.y = self.y + dist as f64 * f64::sin( self.angle * PI / 180.0);
        cr.line_to(self.x, self.y); 

    pub fn turn(&mut self, angle_increment:i64)
        self.angle = self.angle + angle_increment as f64;

Written by smist08

August 8, 2022 at 12:37 pm

Assembly Language Tutorial Five for MagPi Magazine

leave a comment »

I’m in the process of writing a series of Assembly Language tutorials for MagPi Magazine. The fifth one appeared in issue #120 on page 52.

The PDF version of the magazine is free to download, but MagPi always appreciates any donations.

This article leads readers through how to access the Raspberry Pi Pico’s hardware by reading and writing to special memory addresses that double as hardware access and status registers. This is typical of how the ARM processor is interfaced to hardware devices. Since the Raspberry Pi Pico doesn’t run an operating system, our program can directly access the hardware rather than going through device drivers or an SDK. In this tutorial we read temperature values directly from the Raspberry Pi Pico’s built in temperature sensor using Assembly Language. We write this code in the form of a function and call it from a C program that prints out the values for us to read.

This tutorial can only give so much detail. If you want more detail, you can always consider my book RP2040 Assembly Language Programming.

Written by smist08

July 29, 2022 at 10:33 am

Assembly Language Tutorial Four for MagPi Magazine

leave a comment »

I’m in the process of writing a series of Assembly Language tutorials for MagPi Magazine. The fourth one appeared in issue #119 on page 50.

The PDF version of the magazine is free to download, but MagPi always appreciates any donations.

This article leads readers through using the Raspberry Pi’s floating point unit (FPU) to perform a calculation. This article uses the 64-bit of Raspberry Pi OS and shows how to write an Assembly Language routine to calculate the distance between two points in two dimensions. This shows how to use the FPU to add, subtract, multiply and perform square roots. There is a C program that uses this Assembly Language distance() routine to calculate the distance between  a couple of sets of points. The tutorial shows how to use the gdb debugger to step through the program and examine the data as it is calculated.

If you want more detail, you can always consider my book Programming with 64-Bit ARM Assembly Language.

Written by smist08

June 30, 2022 at 1:17 pm

Assembly Language Tutorial Three for MagPi Magazine

leave a comment »

Assembly Language Tutorial Three for MagPi Magazine

I’m in the process of writing a series of Assembly Language tutorials for MagPi Magazine. The third one appeared in issue #118 on page 52.

The PDF version of the magazine is free to download, but MagPi always appreciates any donations.

This article looks at writing Assembly Language code for the Raspberry Pi Pico. The Pico is Raspberry’s entry into the microcontroller market and includes a dual core ARM-M0+ CPU. This CPU runs ARM’s thumb instruction set, a subset of the full ARM 32-bit instruction set. This article shows how to create a project, include Assembly Language source code and then run or debug the program on the Raspberry Pi Pico.

This tutorial can only give so much detail. If you want more detail, you can always consider my book RP2040 Assembly Language Programming.

Written by smist08

May 26, 2022 at 1:51 pm

Assembly Language Tutorial Two for MagPi Magazine

with 2 comments

I’m in the process of writing a series of Assembly Language tutorials for MagPi Magazine. The second one appeared in issue # 117 on page 50. 

The PDF version of the magazine is free to download, but MagPi always appreciates any donations.

This second article looks at writing Assembly Language for the 64-bit version of Raspberry Pi OS. This tutorial shows how to access memory, use 64-bit registers, use loops, conditional logic and call functions. The completed program prints out the value of a register in both decimal and hexadecimal showing how to convert a binary value to ASCII.

This was a fairly long tutorial but I can only give so much detail. If you want more detail, you can always consider my book Programming with 64-Bit ARM Assembly Language.

Written by smist08

April 29, 2022 at 9:58 am

Ubuntu Goes Long Term

leave a comment »


Yesterday, Canonical released Jammy Jellyfish otherwise known as Ubuntu Linux 22.04 LTS. LTS stands for Long Term Release which means this release will receive bug and security fixes for at least the next five years. Ubuntu releases a new version every 6 months, but only releases an LTS version every two years. The LTS version uses more conservative software versions and is generally considered more stable than the other bi-yearly releases. This is the version usually used in data centers to run web servers to ensure they are as reliable as possible.

New Software

Ubuntu 21.10 incorporated version 5.13 of the Linux kernel, this version goes to Linux kernel 5.15 which is a corresponding LTS from the Linux Kernel Organization. The newest released Linux kernel is 5.17, but this isn’t a LTS version and hasn’t received as much testing as 5.15. Similarly all the other software has been updated to newer stable versions such as the Gnome desktop which is now at version 42. The main advantage of Gnome 42 is something called triple buffering which greatly improves performance over previous versions. Similarly all the bundled or easily added software development tools are at newer versions.

The Ubuntu update servers will install the supported and recommended versions for this release, however there is nothing to stop you going to an individual piece of software’s website, downloading and installing their latest release. For instance, today the version of LibreOffice is the latest version, but if LibreOffice releases a newer version and Ubuntu is slow to pick it up, you can install it directly. Although Ubuntu includes an App Store, though all the apps are free, to make installation easier, there is nothing forcing you to use this and you can install anything you wish using the usual Linux mechanisms to do so.

Limited Cross Platform

Linux is cross platform, however Ubuntu only supports Intel/AMD in 64-bits and an ARM version for the Raspberry Pi. Sadly, they discontinued providing 32-bit builds, eliminating some older hardware or running slower due to higher memory requirements. They also don’t provide builds for other hardware architectures like RISC-V, MIPS, PowerPC, etc. Since it’s open source you can always build your own version, but that is a lot of trouble and there are plenty of other distributions that provide builds for these alternative hardware architectures. Ubuntu is based on Debian Linux as are many of these other releases, so they will be familiar to any Ubuntu user. Some hardware vendors will create a special Ubuntu build for their chips or boards, the only problem being that they don’t always update them very often (yes nVidia, I mean you).

Other Stuff

One noticeable change is that the desktop appearance is much easier to customize and there are dark mode equivalents of all items.

Ubuntu has been working hard to fit Linux into corporate environments and a lot of effort has gone into improvements in integrations with Microsoft technologies like Active Directory and NTFS. This is great for corporate users, but not exciting for us hobbyists.


If you are using the last LTS version, namely 20.04 then this will be quite a good upgrade with improvements everywhere. If you are upgrading from the last non-LTS version, namely 21.10 then the improvements won’t be so noticeable. Today, the upgrade tool hasn’t been released, you need to install a clean new image, but that should be appearing in the next few weeks.

One reason I like Linux is because it stays true to being an operating system that stays out of your way and allows you to easily run applications where the application is the important part, not the operating system. Both Windows and MacOS operating systems have become too intrusive with operating system features getting in the way, rather than helping you be productive. Linux is much cleaner, it doesn’t pop up advertisements and best of all it’s free.

So far my experience with Jammy Jellyfish has all been positive and this looks to be another great release from Ubuntu.

Written by smist08

April 22, 2022 at 11:02 am

Posted in Business, linux

Tagged with , ,