Stephen Smith's Blog

Introduction

I reviewed Ubuntu 25.10 late last year on my M1 Apple MacBook Air using UTM virtualization software. Ubuntu 26.04 was released last month which is an LTS version, that’s Long Term Support version which means it will be supported for five years, so I thought I’d have a look at it. This version is also notable in that it is the first Ubuntu release to move to Linux 7.0. Plus, this time I’m running it on my newer M5 Apple MacBook Pro.

Ubuntu is released by Canonical, a London UK based company with South African roots. So far those of us trying to boycott the US, this is a good choice. 

I installed the default Gnome desktop version, but keep in mind there are lots of Ubuntu versions including the server version and then all the various versions using different desktop software like KDE.

Canonical/Ubuntu was hit by a denial-of-service attack when this released, that made getting the version difficult. Currently you can’t access their website via VPN as they have some tight restrictions in place to mitigate the DoS. Hopefully, this gets resolved and access becomes easier again.

Lots of New Versions

With every new Ubuntu version, it updates all the included open-source projects that combine to create a Linux distribution. The main value Ubuntu brings to the table is making sure these all work well together and are compatible with each other. Some of the most notable updates:

• Linux 7.0, a fairly new Linux kernel.
• Gnome 50, now configured with Wayland rather than X11, which I talked about here, in the Raspberry Pi Trixie context.
• New versions of all the apps including Firefox, LibreOffice and GIMP.
• Improved disk encryption.
• Many Linux utilities have been rewritten in Rust for better hacker protection.

Of course, you can manually upgrade most of this stuff yourself on older versions, but it can be a lot of work and sometimes it is nice to get a fresh baseline.

What About AI?

One thing that is nice and clean about an Ubuntu install, is that a whole bunch of AI stuff hasn’t been included by default. Sure, you can install any AI program you want, but nothing is forced on you and nothing is built-in to the operating system.

However, Ubuntu claims this release is much more secure than previous versions, and a lot of that can be attributed to AI tools analysing the Linux code base and finding vulnerabilities in the code.

Anyone checking in patches to the Linux kernel needs to identify if the code is AI generated. People seem to be doing this. Some things are good, but much of the AI slop s rejected and some people have been banned for submitting AI generated bad code, claiming it as their own.

Summary

The installation went smoothly and Ubuntu 26.04 is running well on my M5 MacBook running under the UTM/QEMU virtualization software. Ubuntu tends to be my Linux distribution of choice, largely because the install is painless and I find installing running other software packages easiest on this Linux distribution. I also like that even though this is a stable LTS version, everything is at a fairly new version. Also running Linux is nice because it does what you want without adding a bunch of intrusive crap like ads, popups, unwanted notifications and bogus subscription offers.

Introduction

A couple of weeks ago, I asked ChatGPT to give me a list of blog topics. “Writing Your First ARM Assembly Program (Step-by-Step)” was one of the topics, so I asked Copilot embedded in Microsoft Word to write a blog post on this topic. Below is that blog post.

It looks like Copilot combined my tutorial from one of my books, combined with the introductory tutorial in the ARM Programmer’s Guide. Some things like the exercises/next steps are straight from my book. Other parts are straight from the programmer’s guide, and some are a composite. Overall, the Copilot blog post hangs together, though it introduces 32-bit ARM Assembly and then never mentions it again, as everything else is pure 64-bit.

I gave the program a try on a Raspberry Pi 5 and it worked fine. I didn’t appreciate that it didn’t include me in the Further Reading section, but oh well.

smist08@raspberrypi:~ $ cd Documents/
smist08@raspberrypi:~/Documents $ as -o hello.o hello.S
smist08@raspberrypi:~/Documents $ ld -o hello hello.o
smist08@raspberrypi:~/Documents $ chmod +x hello
smist08@raspberrypi:~/Documents $ ./hello 
Hello, ARM64!

Yay, it worked fine. It created the length variable using Assembler commands and gave an unusual abbreviation of .global, but surprisingly it did work.

Summary

Tools like ChatGPT and Copilot are getting better at generating content. However, if you are familiar with a given field then you can see where it is getting the content and how it is putting it together. Is this different than how a human would write such an article? Especially high school or college students writing an essay?

Not too sure. One thing that is for sure is that this genie won’t be put back in the bottle. Even the online services are shut down, these models can easily be run on a beefy laptop and do a pretty good job.

Will there be a future premium on new original content that isn’t already baked into an AI model? Will these models kill the creation of new original content dooming themselves? Only time will tell.

Microsoft Copilot Generated Blog Post: Writing Your First ARM Assembly Program (Step-by-Step)

A beginner-friendly guide to assembling, linking, and running “Hello, world” on ARM (with an ARM64/AArch64 Linux example).

Assembly can feel intimidating because you’re writing instructions the CPU can execute almost directly—no runtime, no standard library, and very little “magic.” The upside is that your mental model of how programs work (registers, memory, calling conventions, and syscalls) gets sharper fast. In this post, you’ll write a tiny ARM assembly program that prints a message and exits cleanly, then you’ll learn what each line does and how to debug the most common issues.

• How an ARM assembly program is structured (text vs data sections, labels, entry point)
• How to assemble and link with GNU tools (as and ld)
• How Linux syscalls work on AArch64 (arguments in registers, syscall number, svc)
• How to verify the output and troubleshoot common errors

Prerequisites (What You Need)

This walkthrough targets ARM64 (AArch64) on Linux, because it’s common on modern Raspberry Pi models and ARM cloud instances, and Linux provides simple system calls to print text. You can follow along on:

• Native ARM64 Linux (recommended): Raspberry Pi 3/4/5 running a 64-bit OS, an ARM64 laptop, or an ARM64 VM
• Cross-compile from x86_64 (optional): assemble/link with an AArch64 toolchain and run on an ARM64 target

Install the GNU binutils tools (they include the assembler and linker) and confirm you’re on ARM64:

sudo apt update
sudo apt install -y binutils

uname -m    # should show aarch64 on ARM64 Linux
as –version
ld –version

ARM32 vs ARM64: Which Assembly Are You Writing?

“ARM assembly” can mean a few different things. The two most common flavors you’ll run into are:

• AArch32 (ARMv7 / 32-bit): registers are r0–r15, syscalls often use swi 0 in old examples
• AArch64 (ARMv8+ / 64-bit): registers are x0–x30 (with 32-bit views w0–w30), Linux syscalls use svc #0 and place the syscall number in w8

In this tutorial, we’ll build an AArch64 Linux program that calls two syscalls: write (to print) and exit (to terminate). On AArch64 Linux, write is syscall 64 and exit is syscall 93.

Step 1 — Create the Source File

Create a new file named hello.S (capital S is common; it signals “assembly” and allows preprocessors in some toolchains, but lowercase .s also works). Paste the program below:

.data
msg: .ascii “Hello, ARM64!\n”
len = . – msg

.text
.globl _start
_start:
// write(1, msg, len)
mov x0, #1 // x0 = STDOUT file descriptor
ldr x1, =msg // x1 = pointer to bytes to write
ldr x2, =len // x2 = number of bytes to write
mov w8, #64 // w8 = syscall number (write)
svc #0 // enter kernel

// exit(0)
mov x0, #0 // x0 = exit status
mov w8, #93 // w8 = syscall number (exit)
svc #0

Step 2 — Assemble and Link

Assembly source isn’t directly executable. First you assemble it into an object file (.o), then you link it into a runnable ELF binary:

as -o hello.o hello.S
ld -o hello hello.o

Step 3 — Run It

Now execute the binary:

./hello

You should see:

Hello, ARM64!

What the Program Is Doing (Line by Line) 1) Data and code live in different sections

.data is where we put bytes we want in memory (our message). .text is where the CPU instructions live. The assembler and linker use these sections to lay out your final executable.

2) Labels are addresses

msg: marks the address where the string starts. The expression len = . – msg uses the location counter (.) to compute the number of bytes between the current position and msg. That gives us the length without manually counting characters (and avoids the classic “why is my output truncated?” bug).

3) The entry point: _start

Because we’re not using the C runtime, we don’t have main(). Instead we provide a raw entry point named _start. The directive .globl _start makes that symbol visible to the linker so it can mark it as the program’s starting address.

4) Making Linux do the work: syscalls

In AArch64 Linux, a syscall is a contract with the kernel:

• Put the first arguments in x0, x1, x2, x3, x4, x5
• Put the syscall number in w8
• Execute svc #0 to switch into the kernel

That’s why our write call loads x0=1 (stdout), x1=&msg (address), x2=len (byte count), then sets w8=64 and runs svc #0. We do the same pattern for exit with syscall 93.

Troubleshooting (Common First-Timer Errors)

• “Exec format error”: you built an ARM binary but you’re trying to run it on a non-ARM machine (or you assembled for the wrong architecture). Check uname -m and use the right toolchain/target.
• “undefined reference to _start”: the linker can’t see your entry symbol. Confirm you have .globl _start and that the label is spelled exactly _start:.
• “Permission denied” when running ./hello: mark it executable (chmod +x hello), or ensure the filesystem allows execution.
• Output is cut off: your length is wrong. Either update the byte count or compute it (like len = . – msg).
• Assembler errors about syntax: make sure you’re using GNU assembler (gas) syntax (the examples here assume it), and that your indentation/quotes are correct.

Next Steps (Small Exercises to Level Up)

1. Change the message and verify the program still prints correctly.
2. Print twice: call write two times in a row (same register-loading pattern, two svc instructions).
3. Return a non-zero exit code: set x0 to something like 42 before the exit syscall and check it with echo $? after running.
4. Disassemble the binary to see machine code: objdump -d hello.
5. Debug registers step-by-step with GDB (optional): assemble with symbols and step through instructions.

Further Reading

• Arm Developer’s “Hello World tutorial on native AArch64 Linux” (great for tool setup context).
• Peter Nelson’s AArch64 “Hello World” syscall walkthrough (clear ABI explanation and syscall numbers).

Conclusion

You’ve just written a complete ARM assembly program end-to-end: defined data, declared an entry point, invoked Linux syscalls, and produced a working executable. From here, the quickest way to improve is to keep the programs tiny and focused—add one new concept at a time (branches, loops, stack usage, and calling C functions later). If you tell me your exact target (Raspberry Pi OS 32-bit vs 64-bit, bare-metal vs Linux), I can tailor the next post to that environment.

Introduction

In my last blog post, I asked ChatGPT for a list of blog topics. This is the first one it suggested, which I fed into ChatGPT to get a blog post. The interesting thing is that I cover this in each of my books and as I discussed in a previous post, my books have been used to train these AI models, so it is interesting that ChatGPT spat back most of the ideas from my books. I’m not sure if it counts as plagiarism, if ChatGPT plagiarised my books and then I’m using that content?

Anyway, the blog post from ChatGPT is posted below. Does it look like my top ten lists of why to use Assembly Language? It is wordier than my top ten list and it doesn’t seem to know the difference between an interpreted language and a compiled language but otherwise seems more or less ok.

ChatGPT Response

Why Learn Assembly in 2026? Still Relevant or Pure Nostalgia?

Assembly language has always had a certain mystique. It sits right at the boundary between human intent and machine execution—cryptic, precise, and unapologetically low-level. In an era dominated by AI-assisted coding, high-level frameworks, and ever-more abstracted development stacks, it’s fair to ask: does learning assembly in 2026 still make sense? Or is it just a nostalgic exercise for purists?

The answer is more nuanced than a simple yes or no.

---

The Case for “Pure Nostalgia”

Let’s be honest—most developers will never need assembly in their day-to-day work.

Modern languages like Python, Rust, Go, and even C++ offer:

• Highly optimized compilers
• Massive ecosystems
• Built-in safety and productivity features

Compilers today are incredibly sophisticated. They often generate machine code that is better optimized than what most humans could write manually. Add to that the rise of AI coding assistants, and the gap between high-level intent and efficient execution is smaller than ever.

For:

• Web development
• Mobile apps
• Cloud services
• Enterprise systems

…assembly is effectively irrelevant.

So if your goal is purely employability in mainstream software roles, assembly is not a high ROI skill.

---

The Case for “Still Relevant”

Now the interesting part: assembly is far from useless—it’s just specialized.

1. Understanding How Computers Really Work

Assembly strips away abstraction. You see:

• Registers instead of variables
• Memory addresses instead of objects
• Instructions instead of functions

This builds a mental model of:

• CPU pipelines
• Memory hierarchy
• Calling conventions

That understanding pays dividends even when writing high-level code. You start to feel what’s expensive versus cheap.

---

2. Performance-Critical Systems

In certain domains, assembly still matters:

• Embedded systems (microcontrollers, IoT)
• Real-time systems (automotive, aerospace)
• Game engines (tight loops, SIMD optimization)
• High-frequency trading systems
• Cryptography

Even when not writing full programs in assembly, developers often:

• Inspect compiled output
• Optimize hot paths
• Use inline assembly

At the extreme edge of performance, abstraction becomes overhead—and assembly becomes relevant again.

---

3. Reverse Engineering & Security

Assembly is essential in:

• Malware analysis
• Exploit development
• Vulnerability research
• Binary reverse engineering

If you want to understand how software behaves without source code, assembly is the language you’ll be reading.

This field is growing, not shrinking.

---

4. Debugging at the Lowest Level

When things go really wrong—segmentation faults, undefined behavior, memory corruption—assembly is often the only place where truth exists.

Knowing how to:

• Read a disassembly
• Interpret stack traces
• Follow execution flow

…can turn a “mysterious crash” into a solvable problem.

---

5. Learning ARM and Modern Architectures

Assembly isn’t just about old x86 chips anymore.

ARM-based systems dominate:

• Smartphones
• Apple Silicon Macs
• Embedded devices
• Increasingly, servers

Learning assembly today often means learning modern architectures and instruction sets, not just legacy ones.

---

The Hidden Benefit: Better High-Level Code

Even if you never write assembly professionally, learning it changes how you code.

You’ll:

• Avoid unnecessary allocations
• Write cache-friendly data structures
• Understand compiler warnings more deeply
• Recognize performance bottlenecks earlier

It’s like learning how an engine works—it makes you a better driver.

---

When You Should Learn Assembly in 2026

It’s worth learning if you:

• Care about performance or systems programming
• Want to work in security or reverse engineering
• Are curious about how computers actually execute code
• Enjoy low-level problem solving

It’s probably not worth deep focus if you:

• Only build web apps or CRUD systems
• Want the fastest path to shipping products
• Prefer abstraction over control

---

A Practical Approach

You don’t need to go all-in.

A modern, balanced approach:

1. Learn the basics (registers, memory, instructions)
2. Explore compiled output from C or Rust
3. Write small programs (not entire systems)
4. Use it as a tool—not a primary language

Think of assembly as a lens, not a destination.

---

Final Verdict: Nostalgia and Relevance

Assembly in 2026 is both:

• Nostalgic in its roots
• Highly relevant in niche but critical areas

It’s no longer a universal requirement—but it remains a powerful differentiator.

The developers who understand what happens beneath the abstraction layers have an edge. Not always in speed of development—but in depth, precision, and control.

And in a world increasingly driven by automation, that kind of understanding is harder to replace than ever.

---

Bottom line:
You don’t need assembly—but if you learn it, you’ll understand computing in a way many modern developers never will.

Introduction

I started MS Word to create today’s blog posting. When you create a new blank document in Microsoft Word, above the blank document is a dialog that says: “Describe what you’d like to draft with Copilot.” I had a vague idea of what I was going to blog on, so I entered the following in the prompt:

“blog on how AI is harming computing by driving up hardware prices on memory and GPUs, plus how people aren’t choosing computing as a career due to worries of being replaced by AIs”

Copilot then spent a few seconds thinking and produced the blog “How AI Is Quietly Harming Computing: Hardware Inflation and a Shrinking Talent Pipeline” which I’ve included below. Not bad for AI slop.

The quality of the output from the various AI engines has been steadily improving and will continue to improve. This isn’t a bad article, I don’t agree with everything it says, but it wouldn’t take much editing or re-prompting to get it to fully follow my point of view.

So, the question is whether AI is replacing me as a blogger or making me more productive, as AI helped me produce this blog in five minutes. Which means I can easily produce dozens of articles a day if I feel like it. For that matter I can ask AI to give me a list of blog topics (see the very end of this article).

So basically, I can automate the whole blog writing process, having AI create the topic and then AI create the blog article. I feel this how most tech publications have evolved and why I don’t find any value in reading them anymore.

The thing is, I enjoy blogging and it helps me getting my thoughts in order. I don’t get paid for this blog, so there is no value to me in extra volume. Plus, I’m not sure a blog of pure AI slop will produce readers. Most technology publications are oriented to getting click bait these days, which then triggers the advertising hits which isn’t what I’m looking for.

But anyway, a quiet morning seeing how the current generation of AIs are going.

How AI Is Quietly Harming Computing: Hardware Inflation and a Shrinking Talent Pipeline

For decades, “computing” has been the great equalizer. A cheap laptop and an internet connection could be enough to learn, build, experiment, and launch a career. But in the last couple of years, something has shifted: AI hasn’t just changed what we do with computers—it’s changing who gets to participate in computing at all.

Two trends are reinforcing each other in a way that should worry anyone who cares about the long-term health of the field:

1. AI is driving up the prices (and scarcity) of key hardware—especially GPUs and high-bandwidth memory.
2. Many prospective students and early-career technologists are hesitating to enter computing because they fear AI will replace them.

Individually, each issue is manageable. Together, they create a feedback loop that makes computing more expensive to access and less attractive as a career.

1) AI is pricing people out of serious computing

AI workloads—training large models and running high-volume inference—are brutally hungry for compute. The modern AI stack is optimized around:

• GPUs (and similar accelerators) for parallel matrix-heavy operations
• Memory bandwidth (HBM in datacenters, VRAM on GPUs, and fast system RAM)
• High-throughput interconnects that keep many accelerators fed

This has consequences beyond AI labs.

GPUs: from “nice-to-have” to “financial barrier”

GPUs used to be a straightforward upgrade: useful for gaming, creative work, and some specialized compute. Now they’re strategic resources.

When cloud providers and large AI companies buy GPUs by the tens of thousands, they reshape the market:

• Supply gets tighter.
• Mid-range cards creep upward in price because demand pressure rises across the product line.
• Used markets become distorted (cards get snapped up for AI experimentation or resold at inflated prices).

For students, hobbyists, and independent developers, that means the difference between:

• experimenting locally vs. not,
• doing a real project vs. a toy demo,
• learning deeply vs. staying on the surface.

Memory and bandwidth: the hidden inflation

Even when you can get a GPU, memory is increasingly the bottleneck:

• Larger models and datasets push for more RAM/VRAM.
• Higher-end configurations command large premiums.
• “Enough memory to do real work” starts to look like a luxury, not a baseline.

And that cost hits more than AI projects. It hits:

• scientific computing,
• graphics and simulation,
• software development environments,
• local virtualization and containers,
• game development,
• security research.

In other words: fields that historically benefited from affordable “prosumer” hardware are now competing with AI spending.

“Just use the cloud” isn’t a real solution for everyone

A common response is: don’t buy hardware—rent it. But cloud compute introduces its own barriers:

• Paying by the hour penalizes learning-by-exploration.
• Students can’t always justify unpredictable costs.
• Free tiers rarely cover GPU needs for meaningful work.
• Data privacy and compliance can block cloud use for many projects.

Local compute still matters for access, iteration speed, and experimentation. When local compute becomes unaffordable, fewer people can get good.

2) AI is discouraging people from choosing computing as a career

At the same time hardware is getting harder to access, the career narrative around computing has changed dramatically.

Many students are hearing some version of:

• “AI will write all the code.”
• “Junior developers won’t be needed.”
• “Why study CS when models can do it instantly?”

Even if these claims are exaggerated, they’re powerful—because career choices are made under uncertainty. When someone is deciding what to study, they’re not optimizing for what’s technically true; they’re optimizing for what feels safe.

The psychological impact is real

A lot of people don’t want to enter a field where they feel:

• perpetually behind,
• constantly compared to a machine,
• or “replaceable by default.”

That fear doesn’t just reduce enrollment—it changes behavior among people who do enter:

• They avoid deep fundamentals because “tools will handle it.”
• They over-focus on short-term prompts and frameworks.
• They invest less in long-term mastery.

That’s not a moral failing; it’s rational adaptation to the incentives and messaging they’re seeing.

The paradox: AI increases demand for computing judgment

Here’s what’s being missed: even if AI can generate code, it doesn’t eliminate the need for people who can:

• define the right problem,
• evaluate tradeoffs,
• validate correctness and security,
• understand performance and failure modes,
• build reliable systems under real constraints,
• and take responsibility when things break.

AI changes the workflow. It doesn’t remove the requirement for competence. In many environments, it raises the bar—because the cost of confidently shipping the wrong thing becomes higher when output is produced faster.

But the public story is not “the bar moves,” it’s “you’ll be replaced.” And stories shape pipelines.

3) The feedback loop that should scare us

These trends reinforce each other:

• Hardware inflation makes it harder for newcomers to build the skills that differentiate them.
• Career anxiety reduces the number of newcomers willing to try in the first place.
• Fewer learners means fewer contributors, fewer open-source maintainers, fewer researchers, fewer builders.
• A smaller talent pool increases dependency on a handful of well-funded companies and platforms.
• That concentration further accelerates AI-driven hardware purchasing—because the winners scale up even faster.

If computing becomes something you can only seriously practice with either:

• a large budget, or
• corporate infrastructure,

then we lose one of the most productive features of the last 40 years: the ability for outsiders to become insiders through personal projects.

4) What would actually help (practical steps)

This isn’t a call to “stop AI.” It’s a call to stop ignoring the collateral damage.

Make compute access a public good (at least for learning)

• More GPU-equipped labs in universities and public institutions.
• Transparent, predictable student access programs (not lottery-based credits).
• Community compute cooperatives and shared clusters with fair scheduling.

Build a culture of “AI as a tool,” not “AI as the employee”

In education and hiring, reward:

• system understanding,
• debugging and evaluation,
• security thinking,
• performance intuition,
• and requirements clarity.

If entry-level work becomes “prompt the model,” we’ll accidentally train people to be fragile. If entry-level work becomes “use the tool while proving you understand the system,” we’ll train durable engineers.

Be honest about which jobs are changing—without pretending the whole field disappears

Yes, some tasks will be automated. But the answer is not to discourage people from computing—it’s to teach what remains valuable:

• fundamentals,
• ownership,
• reliability,
• and domain expertise.

Conclusion: computing is at risk of becoming less open

AI is not only transforming software; it’s transforming the economics and the psychology of entering the field.

When GPUs and memory become expensive, the on-ramp gets narrower. When young people fear replacement, fewer step onto the ramp at all. That combination risks turning computing into a gated discipline dominated by whoever can buy the most hardware and hire the most talent—rather than whoever has the best ideas.

If we want computing to remain a broad, accessible engine of opportunity, we need to treat hardware access and career messaging as first-class issues—not afterthoughts.

---

If you tell me your preferred tone (angry, neutral-analytical, or personal/first-person) and your target length (e.g., ~800 vs ~1500 words), I’ll tighten this into the exact version you want.

Create a list of blog topics

Create a list of blog topics for a technology blog on assembly language programming, arm processors and technology trends.

Here are some blog topic ideas that blend assembly language programming, ARM processors, and broader technology trends—with a mix of practical, conceptual, and opinion-driven angles:

---

 Assembly Language Fundamentals & Practice

• “Why Learn Assembly in 2026? Still Relevant or Pure Nostalgia?”
• “From C to Assembly: What Your Compiler Really Generates”
• “Debugging at the Metal: Using Assembly to Solve ‘Impossible’ Bugs”
• “Understanding Memory Layout: Stack vs Heap Through Assembly”
• “Writing Your First ARM Assembly Program (Step-by-Step)”

---

 ARM Architecture Deep Dives

• “Inside ARM: Why It’s Winning the CPU Wars”
• “RISC vs CISC in Practice: ARM vs x86 Explained”
• “Exploring the ARM Instruction Set: A Practical Guide”
• “How ARM Powers Everything from Phones to Servers”
• “What Makes Apple Silicon So Fast? A Look at ARM Optimization”

---

 Performance & Optimization

• “Hand-Optimizing Code in ARM Assembly: When It’s Worth It”
• “Cache, Pipelines, and Branch Prediction: A Low-Level Perspective”
• “SIMD and NEON: Unlocking ARM’s Hidden Performance”
• “Why High-Level Languages Still Rely on Assembly-Level Tricks”
• “Micro-optimizations That Actually Matter (and Those That Don’t)”

---

 Security & Reverse Engineering

• “How Malware Uses Assembly to Evade Detection”
• “Reverse Engineering ARM Binaries: Tools and Techniques”
• “Buffer Overflows Explained Through Assembly”
• “Secure Coding Starts at the Machine Level”
• “Firmware Hacking: Peeking Inside Embedded ARM Devices”

---

 ARM in the Real World

• “How ARM Took Over Mobile—and Is Coming for Desktop”
• “The Rise of ARM Servers in Cloud Computing”
• “Raspberry Pi Projects That Teach You Assembly”
• “Embedded Systems Programming with ARM Microcontrollers”
• “Battery Efficiency and ARM: Why It Matters”

---

 Technology Trends & Big Picture

• “The Shift Away from x86: Is ARM the Future of Computing?”
• “Custom Silicon: Why Companies Are Designing Their Own ARM Chips”
• “AI at the Edge: How ARM Enables On-Device Intelligence”
• “Energy-Efficient Computing: ARM’s Role in a Greener Future”
• “Will Assembly Make a Comeback in the Age of AI?”

---

 Experimental & Thought-Provoking

• “Writing a Tiny OS Kernel in ARM Assembly”
• “Can You Build a Compiler Without Understanding Assembly?”
• “What Happens When You Optimize Too Much?”
• “Assembly vs AI-Generated Code: Who Wins?”
• “The Beauty (and Pain) of Programming Without Abstractions”

---

 Tools & Ecosystem

• “Best Debuggers and Disassemblers for ARM Development”
• “Getting Started with GNU Assembler (GAS) for ARM”
• “Cross-Compiling for ARM on x86 Machines”
• “Using QEMU to Emulate ARM Systems”
• “Modern IDEs That Actually Support Low-Level Development”

---

If you want, I can refine this into:

• a content calendar,
• SEO-optimized titles, or
• topics tailored to beginners vs advanced readers.

Introduction

Google, Apple, Amazon, Facebook and Microsoft offer single sign-on solutions to simplify signing on to a variety of websites and other services. If you are already signed on to Gmail, you can go to a new website and opt to use this Gmail sign-on to use this website. This is quicker and easier than creating a new user id and remembering another password. The downside is that you are now giving this new website your main Gmail e-mail, which might be used for spam, and you are giving Google extra information on all the websites you visit and use. Google then can profit by using this for targeted advertising and selling the information to third parties.

In my attempts to free myself of using Google this is a tricky one. This article looks at the pros and cons of single sign-on along with some alternatives, which while perhaps not as easy provide extra protection and privacy.

Pros and Cons of Single Sign-on

The main reason to use single sign-on is that it gives you a consistent simple sign-on process across much of the web. You only have one password to remember, and password recovery is not too bad. If using two factor authentication, this simplifies the usage. Some sites only allow single sign-on, offering no alternative forcing you into this. If you have a choice of providers to use, I recommend Apple, if possible, followed by Microsoft, Google, Facebook and Amazon last.

The Cons are as follows:

1. You are sharing more data than necessary with the site you are signed onto; they get access to more data from your Google (or other) account than you expect.
2. This tends to result in a lot of spam as your main e-mail is given to many websites any of which could sell it to bad actors.
3. A single data compromise (such as your account being hacked) will compromise all the services tied to this.
4. It’s a single point of failure, if Google goes down, you have trouble with your account, or Google bans you then you lose access to everything.
5. Google is getting more information on you than necessary allowing more aggressive advertising.
6. It makes it difficult to stop using Google entirely. Switching emails is easier.
7. If you accidentally leave a browser logged in at a public terminal, like at the library, the next person has access to a lot of your services.

Some Alternatives

The old-fashioned way would be to create a new user-id for each website, each with its own password. This is more work and leads to password fatigue where people tend to reuse the same passwords over and over.

Browsers have started offering unique strong passwords whenever they see this process happening. This ties you to a given browser, and if the browser is Chrome, you are giving the same data to Google as SSO does.

The best option is to use a password manager not created by a US Tech giant. I use Proton’s password manager myself. This integrates with many programs and browsers and gives a great way to manage all these passwords seamlessly without giving all your data to US Tech. If you use their generated strong passwords, you are safe.

This still has the problem that you are giving your e-mail address to all these sites, and this can lead to receiving a lot of spam. Spam filters will eliminate much of this, but it is still a hassle. You could have a second e-mail address that you only use for sign-on and then ignore all the e-mail it receives. A better option is if you use Proton Mail, it will generate a unique e-mail address for each site you use for sign-on, then you can see which the bad site is selling you out and delete it. Integrated with Proton’s password manager, this is easier than it sounds.

A related problem is two factor authentication. Rather than sending a code in a text, many sites expect you to use Google authenticator or the Facebook app. Generally, you don’t want these US Tech companies knowing what you are doing. One alternative is the open source 2FAS authenticator app. If this works for the service, then great. Otherwise try to stick to text messages.

Summary

Unravelling from using the US Tech giants, particularly Google, is a long process. However, when you study the alternatives and take the time to switch to them, you end up in a much better place. Single sign-on and two factor authentication are services that seem to only be offered by the US Tech giants. They do make life easier but tend to gloss over the downsides. Switching to alternatives is a bit of work and requires a different mindset but does result in something better in the end.

Introduction

AI companies such as OpenAI, xAI, Meta, Anthropic and Google have been in the news a lot recently for all the wrong reasons. None of the AI products are profitable and all require huge investments to progress. This desperate need for funding is undercutting all safeguards and pushing AI down some rather dubious paths. This article looks at some of the recent bad trends in AI.

I’m not saying all AI is bad, just that the good and useful cases are being overshadowed by the bad. It makes the people using the good cases worry about using the products they are using, given how much bad they are being used for.

AI for the Military

Anthropic was in the news in a good way for refusing to let the US government use its product for unsupervised weapon systems and domestic surveillance. OpenAI then stepped in and agreed with everything the US government wanted. As a result, OpenAI gets giant US military contracts and Anthropic has been banned from use by the US government. OpenAI has agreed to allow its AIs to control weapon systems with no human supervision and to help the US government identify and round up people for all the internment camps that have been created.

AI is being used to identify targets in Iran, for instance AI guided multi-million-dollar missiles blowing up pictures of helicopters whose outlines have been painted on roadways. It seems like the missile strikes inside Iran are far less accurate than what we saw in Iraq in 1991. Hospitals, schools and apartment buildings are being alongside military targets. Is this due to AI’s providing the guidance rather than humans?

AI Assisting Domestic Terrorists

It was revealed that the Tumbler Ridge shooter, Jesse Van Rootselaar, used OpenAI’s ChatGPT and was banned for their violent requests. Of course, Jesse opened another account and happily proceeded. OpenAI never alerted authorities. OpenAI only has a small team policing these things and probably compared to what Americans discuss, this didn’t really stand out. OpenAI is apologising, but a little too late.

The Canadian government is working with OpenAI to notify them more on these sorts of things, but I don’t think the government realises the scope and scale of the problem. Likely they are going to be tasked with investigating thousands of these and will be completely overwhelmed. I also think OpenAI is looking for the government offload the cost of this, saving them some money.

AI Causing Job Losses

The US Jobs data came out today and it looks bad with unemployment up and jobs being lost rather than created. Many companies are having large layoffs claiming that AI is taking over these jobs. These are mainly customer support positions, many in companies which have terrible customer support to start with like airlines. Many of these AI job replacement projects end up failing or giving companies a black eye with bad service, but the attraction to CEOs to save money is unstoppable.

Corporate clients paying for large contracts is the AI companies main hope for revenue to cover their costs. This is their best chance to shift their cash needs from investors to companies. Hence, they are all aggressively selling this as hard as they can.

Revenge and Child Porn

Meta (Facebook) is currently being sued by the adult film industry for training its AIs using 10TB of adult film videos without permission (or recompense). This shows why the current AIs are so good at producing revenge porn and child porn. Morphing between two images or videos is an area where AI is quite strong. Hence, it does a good job of taking pictures of an ex or coworker and making a porn movie or nude photos. The same is true for children.

xAI is using this as a revenue source, when the extent of this usage was discovered rather than ban it, xAI made sure it was only available on the paid tiers of their service and not available for free.

AIs Use by Criminals

Scams are becoming increasingly sophisticated. AIs can simulate friends and families’ voices with amazing accuracy. They are also getting better at imitating the CRA and police. Again, the AI companies don’t seem to police this as these are a big group of their paying customers.

Along the same lines AIs are being used for cyber-attacks both on businesses, individuals and governments. These cyber-attacks are becoming as sophisticated as those launched by the NSA and other intelligence agencies.

Introduction of Bias and Misinformation

I blogged about this previously. It seems some AIs are intentionally introducing bias, misinformation and toxic content to please various extreme politicians.

Solutions

As the AI companies become increasingly desperate for a return on their giant investments, they seem to be selling into more dubious markets. They spend huge amounts of money, paying politicians to not regulate them. However, at some point the politicians must act for the good of the people, rather than their personal fundraising, and introduce some sort of guard rails with strong penalties against the bad actors.

When Anthropic stood up to the US military and OpenAI jumped in whole heartedly, there was a considerable consumer backlash. Many people cancelled their ChatGPT accounts and created Anthropic accounts, leading Anthropic’s Claude AI to be the number one app in the Apple store. This shows consumers still have power to reward good behaviour and to punish companies that are doing things they don’t like.

Summary

Although the current AI programs are extremely useful and can be used for all sorts of good things, increasingly they are being used for evil. Further, the AI companies seem to be pursuing these markets for revenue. Without any sort of regulatory framework I doubt they are going to change their ways. 

Introduction

US Tech companies are Trump’s biggest supporters and seem intent on doing harm to everyone’s democracy and freedoms. All in the fear of regulation and taxation. Most US tech companies don’t pay tariffs and pay very little income tax. The harm they are doing both by themselves and in supporting authoritarian regimes and parties around the world is devastating. I previously blogged on switching away from Google and I posted a review of the Proton apps which offer many alternatives to Google services.

I recently attended a presentation by the local Tech Resistance which is part of Charlie Angus’s Resistance network. It was interesting in that they approached the companies to avoid in a different way than I did, but then the result was the same bad actors. I have been focused on boycotting companies that support Trump, via paying for his inauguration, contributing to the Epstein ballroom in the White House, or donating millions to PACs that support Trump and the republicans. Whereas the Tech Resistance looked at companies that cause harm locally in our neighborhood or commit atrocities internationally. They focused on those causing environmental catastrophes, those supporting ICE with products and services, those supporting Israel with products and services, those spreading misinformation, those spreading child pornography or generating revenge port. Anyway, quite a long list. And interestingly the same companies that actively support Trump.

This article is a continuation on my efforts to wean off American Tech. Some things are easy, some more difficult.

Switching E-Mail

I started switching by switching from Gmail to Proton Mail with the various e-mail lists I’m on. This moved a lot of my e-mail right away. Then I judged e-mails I receive and either edited the source to the new e-mail or unsubscribed. Some I had to unsubscribe and then resubscribe. I switched the notifications on my phone and watch, so I’m notified when I receive Proton mail, but not Gmail. Hence those using my Proton mail address will get a faster response. Next, I’m going to start moving my personal contacts, so we’ll see how that goes.

Proton Drive vs Google Drive

I’m moving off Google Drive and as a result have freed up a lot of space there. Since I subscribed to Proton Drive and have 500GB, I uploaded all my photos to Proton and deleted all my photo albums from Google Photos. One thing I’ve found on my iPad is that the browser interface to Proton Drive works far better than the app. The app is slow to update and not all that responsive, whereas the web version seems to always work well.

Chrome to Duck Browser, and Google Search to DuckDuckGo

I now use the Duck browser for nearly everything. There are only a couple of things I use Chrome for such as editing websites with Google Sites and accessing Amazon Prime. I maintain two club websites in Google Sites, and I really should move them to WordPress or something else, but that is a lot of work. Similarly, I should wean myself off Amazon and cancel my Prime subscription.

The other thing I something use Google for is to check business hours as the store hours in Google are the most likely to be up to date.

Maps and Directions

DuckDuckGo doesn’t have a map feature and tends to integrate with Google. There is an open source map service OsmAnd, but they don’t seem to automatically integrate with this and it doesn’t include real-time traffic info.

My car has Apple CarPlay which seems to work well with Apple or Google Maps. I try to use Apple Maps since Apple seems a slightly better corporate citizen than Google.

Authentication

The two main sign-in authentication services are Google and Microsoft. Previously, I’ve used Google, but I’m trying to get off that. Proton mail and password manager offer a service where you can generate a new email for each new sign on and then store the password in Proton Password Manager. This isn’t as easy as just using the Google service when encountering new websites. On the plus side, if you start receiving a lot of spam you can tell which website or service sold you out via the uniquely generated email id. Anyway, I’m trying to use this going forwards to reduce my usage of Google sign on and authenticator. Some websites require a sign on service, then I choose Apple over Google or Microsoft, but I’m not entirely happy about that.

Resistance Recommended Alternative Services

Here is the list of Tech Resistance alternative platforms:

US Large Tech ServiceBetter AlternativeGoogle GMailProton MailMicrosoft OfficeLibreOfficeWhatsAppSignalChatGPTThauraDropboxSync.comChrome/SafariDuck BrowserWix/ElementorWordPressX (formerly Twitter)BlueskyTikTokUpScrolledNetflix/Disney/Amazon PrimeWatermelon/Crave/Gem/CriterionSpofifyDeezer/Qobuz

Tech Resistance companies to avoid or be wary of: EventBrite, Dell, Meta Companies (FB, WhatsApp, Instagram), Fivrr, Amazon, Humanitix, Microsoft, IBM, HootSuite, LinkedIn, Nvidia and Salesforce.

Summary

Moving off US based Tech companies whether due to their support of Trump or to all the other evil things they are involved in, is a bit of a long process. However, don’t expect things to get better. The sooner you start the sooner you will be free of them. Once you are disentangled from US tech, you are a lot freer to make your own choices and control your own destiny. You are much harder to coerce and influence when you aren’t reliant on all these products. It also opens you to a much wider world of tech which include innovations by smaller international companies that you would otherwise likely miss out on.

Introduction

Today the Supreme Court of the US ruled that most of Trump’s tariffs are invalid and illegal. This doesn’t affect Canada so much as most of our exports are covered via CUSMA and some of the other tariffs were created by congress and hence still in effect.

Combined with all the Epstein revelations of child rape by Trump and his buddies, he is starting to act as a trapped animal. He mainly ran to be president again to avoid going to prison and now with the midterms looking bad for him, he is getting worried.

The economic numbers released today don’t look good, with inflation up, GDP growth slowing and unemployment on the rise. Things that his rather insular base care about and things FOX news actually reported on.

He’s already throwing out distractions as fast as he can, including:

• Announcing weird things about space aliens.
• Starting a war with Iran.
• Embezzling billions of dollars into his board of peace.

More Chaos Likely

So, what will he do next? Accept things? Resign? Will his cabinet invoke the 25th amendment? I doubt any of these things will happen. Instead, more distractions, more cruelty and more turmoil. What are some likely things he might do?

1. Invade Iran.
2. Invade Cuba.
3. Invade Greenland.
4. Invade Canada.
5. Invade Mexico.
6. Ramp up ICE raids on any city where anyone speaks out against him.
7. Use the DOJ to start prosecuting more of his enemies? 
8. More tariffs rather than fewer.
9. More bullying of other countries.
10. More voter suppression laws.
11. Tear up CUSMA.

I’m sure Trump, Miller and company can think up even worse things to cause distractions and have previous failures drop out of the news cycle quickly.

What to Do?

Fortunately, here in Canada we are somewhat insulated from the craziness. We have our own Trump wannabe in Danielle Smith, but at least at this point her referendums can be voted against and will face the scrutiny of an impartial supreme court. Short of Trump invading Canada, we need to just stay the course.

1. Don’t travel to the USA. It is becoming less safe. Plus, the current volunteer boycott is working.
2. Keep diversifying the economy with new trading partners. This is going well and growing the economy. The US is going into a recession and trade with them will decrease even if free trade is renewed.
3. Keep investing locally and promoting and following buy Canada. Remove any remaining internal trade barriers to speed this up.
4. Migrate away from US tech companies like Google, Amazon, Microsoft, X and NVidia. Pressure all government agencies to get off of X.
5. Investigate and prosecute American political interference in Canada, especially in Alberta and Ontario.
6. Don’t doomscroll, things are going to get bad in the US. Don’t let it affect your mental health. They crave attention, don’t give them so much.

Summary

Right now, I’m so thankful that I’m Canadian living in Canada. Things are actually pretty good here. Despite the USA, the economy is still strong, and our natural resources are in demand around the world.

We need to keep diversifying away from the US. We need to block US interference and need to keep building alliances with the rest of the world. This is working and we need to stay focused and not fall for all the distractions happening south of the border.

Introduction

There has been quite an explosion of Generative AI programs recently including OpenAI’s ChatGPT, Facebook’s Llama, Google’s Gemini, Microsoft’s Copilot, Anthropic’s Claude, and xAI’s Grok. All of these are quite good, but some of them have been known to produce toxic and biased results. In fact, Elon Musk made a point of making Grok do so. This article looks at how these models are trained and how companies try to either remove or add toxic and incorrect data.

The Training Process

AI models are often advertised based on their number or parameters, typically in the billions. If an AI model has 90 billion parameters, that means there are one or more matrices in the models containing 90 billion elements (numbers). What are these numbers? Where do they come from? This is the training process for an AI model. This training process takes a large amount of data, like books and web pages and iteratively feeds it through the model until the model learns the data it is being fed. It typically takes 200 times the amount of data for training as there are parameters and the training process is extremely CPU intensive, often taking tens of thousands of specialty processing units, months to complete. After the model is trained, there is a further reinforcement learning phase where good responses to prompts are fed in to give the model an idea of what is expected.

Where bias and toxicity enter in is in the data fed into the model initially and then the quality of the data in the reinforcement phase at the end.

Creating the Training Data

To create the volume of training data, the AI companies tend to use all the uncopyrighted books they can get a hold of. Plus, they run web crawlers that accumulate all the web content they can access. Further, they license access to large databases of content. That’s not to mention all the copyrighted materials they use without permission or financial compensation. xAI also uses Twitter (X) data since they are both Musk companies.

This giant accumulation of data is a big mess that needs to be cleaned up. For instance, if you are creating an English language chatbot, then you want to delete any non-English text. Next several heuristics are used, for instance:

1. For web pages delete any page with words repeated 100 or more times.
2. Remove any pages where the symbol to word ratio exceeds 0.1.
3. For forums, remove any comments with less than three likes.
4. Use an AI model to identify biased and toxic data.
5. For privacy remove any phone numbers, email and IP addresses.
6. Remove pages with less than 25 words.
7. Remove HTML tags from web pages.
8. Discard any pages without connecter words like the, of, and, that, etc.

A typical AI model to identify toxic content is based on the Jigsaw dataset which contains nearly 160,000 forum comments, each of which has been manually annotated with six categories, including “toxic,” “severely toxic,” “threatening,” “insulting,” “violent,” and “identity hate.”

It would be nice if each model made this sort of information public, so people could decide for themselves whether the data and cleaning methods are something they are comfortable with. Some sort of government disclosure regulation would be nice.

Generally, the rule is that any of these Ais are only as good as the data used to train them. There has been a lot of research into removing biased and toxic content, so why is it creeping in?

The Controversy

This filtering of toxic content led to many complaints by Trump and the right wing that their beliefs were being censored and it was somehow affecting their rights to free speech. After all, the original creators of these AIs were careful to remove antisemitic, racist, anti-vax, climate change denialism and other anti-science content which led to all the complaints. They didn’t like that these Ais believed in the holocaust, that the color of your skin didn’t matter, that climate change was real or that vaccines were good.

The response to this by xAI under Elon Musk’s direction was to stop filtering out toxic content and instead filter out “woke” content. Combined with using highly toxic Twitter data as input led to quite the racist right wing chatbot. This pleased Trump which I guess was the goal.

It feels like a lot of social media posts by Trump are generated by a rather toxic AI that is disconnected from reality and massively hallucinating. Maybe he uses Grok.

Summary

There is still a lot of research to be done to remove bias and toxicity from generative AI programs. This is related to removing hallucinations along with other inaccurate answers. Some of this is controversial, and subject to political interference, but researchers are making progress. To some degree the USA is losing its leadership position in AI research due to the directives to include toxic, biased and inaccurate data in their training models which degrades the quality of their AIs.

Introduction

Over the past couple of days Amazon, Google, Microsoft and Meta have seen their stocks plummet when they released generally good earnings, but gigantic plans to each spend about $200 billion over the next year building out new data centres and compute capacity to power their AI ambitions. All these companies already possess a huge number of data centres and gigantic compute resources. Why do they need so much more? And will these huge investments ever pay off? Let’s look at what these companies are doing with all these billions of dollars of servers.

Generative AI

Generative AI is a branch of AI that generates text, images, videos or music. It tends to do it incrementally, so if it has constructed “The capital of China is” then the generative algorithm would probably produce “Beijing” as the next word. These AI models consist of anywhere from tens of billions of parameters to trillions of parameters, these parameters are usually the coefficients of a giant matrix which is multiplied by the input prompt to produce the output (usually with a few more steps). Determining these parameters is called training. The training process involves taking giant amounts of text data and iteratively running it to produce the coefficients of the matrix. For a model to work well usually requires training data that is 200 times the number of parameters.

When Open AI was founded, they tried to create GPT using recurrent neural networks which theoretically would work great, but couldn’t be trained in parallel, so the number of GPUs doing the training couldn’t be expanded to speed things up. As a result, Open AI couldn’t release anything. Then Google came up with what is called a “Transformer Model” which theoretically isn’t quite a good as a recurrent neural network but can be easily trained in parallel. Open AI jumped on this and produced GPT-1 which started the whole Generative AI race among all these companies.

For a state-of-the-art model like ChatGPT, it will have several hundred billion parameters and training will require ten thousand GPUs running for several months to complete. The scaling of these models is exponential so as the models increase in size, the data centre requirements become gigantic quickly. 

Besides the computing resources, having 200 times the number of parameters in training data is a real challenge. At this point it simply requiring pretty much every book ever written to be included in the training set, along with huge amounts of data scraped from the Internet.

Emergent Properties

It looks like by throwing huge computer resources at the problem, you can incrementally improve your model. Given that the current models are pretty good, why are companies throwing such huge resources at doing this? The answer is the phenomenon of “Emergent Properties”. As the number of parameters and the size of the model is increased, the performance and capability of the model doesn’t increase smoothly. In fact, as you hit certain levels, suddenly there are huge improvements in capability. It is a bit like a child learning individual words and then suddenly stringing them together as sentences, this happens suddenly and unpredictably.

What researchers are selling to these corporation’s finance departments is that if they keep increasing their model sizes and the amount of training data, new emergent properties are going to emerge. These aren’t predictable but they are significant and whoever achieves these will reap great benefits. This is why Open AI’s GPT 3 was so much better than GPT 2 because increasing the number of parameters made such a giant leap in its capabilities.

Some even think this is the road to true artificial general intelligence (AGI) and will lead to the singularity. Already, these models are being used to create their next generations. Part of this race for more hardware is to iterate faster with the AI models generating the iterations.

Costs to Society

This AI buildout is great for the companies like NVidia that create the hardware, but for the rest of us, there are some downsides. We are all experiencing high RAM prices and generally all our laptops and computers are too expensive as a result. Then there are the electricity demands making electricity more expensive for all of us. The data centres use huge amounts of water for cooling, which dries out local communities. Then there is the amount of carbon produced, since most of the data centres get their electricity via the burning of fossil fuels.

A Couple of Books

A couple of recommended books on Generative AI:

1. Generative Deep Learning: Teaching Machines to Paint, Write, Compose, and PlaySummary, Second Edition by David Foster. This book teaches how to create Generative AI programs using TensorFlow. It uses simple small models that you can run on your laptop. This book covers things quickly, so having prior experience with TensorFlow and traditional machine learning algorithms.
2. Large Language Models by Wayne Xin Zhao, Kun Zhou, Junyi Li, Tianyi Tang and Ji-Rong Wen. A new book with up-to-date information on Generative AI and all the problems and techniques to scale them.

Summary

It will be interesting to see if any new emergent properties arise over the next year. It will also be interesting to see if these companies can find a revenue model to pay for all these investments as most people only use the free versions of their products. On the downside, most days this February in the Pacific Northwest have set new temperature records for the daily highs and global warming is really kicking in and this will accelerate it.