IBM AIX for IA64 runs again

Project Monterey was an attempt to unify the fragmented Unix market of the 90s in to a single cross vendor Unix that would run on Intel Itanium (and others). The main collaborators were: IBM who brought its AIX, HP was supposed to bring some bits from HP-UX, Sequent from DYNIX/ptx and SCO from UnixWare. The project shared fate of Itanium – it totally failed. In the end Linux took its spot as a single Unix. The main legacy of Project Monterey was the famous SCO vs IBM lawsuit.

IBM did however produce AIX version for IA64 architecture! According to Wikipedia, 32 copies were sold in 2001. Except of course no one has kept a copy and the famous OS was lost forever.

Until now! This rare release has been recovered, imaged, and uploaded for posterity. It’s going to be difficult to actually run it, though, as there’s no emulator capable of running it – you’re going to need a very specific type of Itanium machine, an Intel Engineering Sample Itanium workstation, which were available from several vendors.

The MIPS ThinkPad, kind of

Say hello to the RISC ThinkPad that’s not a ThinkPad, the IBM WorkPad z50.

[…]

Let’s say you went to CompUSA, or, I dunno, Fry’s, or Circuit City, in mid-1999. Why, you might pick up an Ethernet hub and a BeOS advanced topics book, and marvel at this lithe little laptop IBM was selling for US$999 ($1780 in today’s dollars) MSRP. It had all the ThinkPad design cues and a surprisingly luxurious 95% keyboard, plus that frisson-inducing bright red mouse stick. And you might say, I want this, and I’m going to take it home.

I want one of these so very bad – but like so many things classic computing, eBay prices have gone batshit insane, making it very, very hard to justify.

Anatomy of a PumpkinOS app

We have seen how PumpkinOS runs a classic 68K application. First, code.0 and data.0 resources from the PRC are loaded and decoded. Then code.1 is loaded and the 68K emulator starts running it. Native applications, that is, applications compiled from source to the target architecture of PumpkinOS (x86 or ARM), are still stored in PRC files, having access to all PalmOS resources like forms, bitmaps, alerts, etc. In fact, the same resource compiler (pilrc) used to generate the binary resources for PalmOS is used in PumpkinOS. The difference lies in how code and data are stored and processed.

PumpkinOS’ developer also sent out a tweet with a video of a new shell – which looks quite cool.

GNOME 43 released

After nearly six months of development, the GNOME 43 “Guadalajara” desktop is finally here and introduces a few interesting changes, the most prominent one being the Quick Settings menu that can be accessed from the system top bar, very similar to those you probably saw on Android devices or the latest Windows 11 and macOS systems.

Nautilus has also been improved considerably, and Epiphany (GNOME Web) now supports WebExtensions, instantly making the browser a lot more useful. The move to GTK4 continues, too, of course, and there’s countless other improvements.

Hacking anything with GNU Guix

Perhaps my favourite feature of Guix is guix shell. It is one of those tools that I don’t know how to do without. Even if you are not ready to use Guix as a package manager (or distro), guix shell alone might be a reason to have Guix installed.

Why?

This article describes a really nifty feature of Guix.

Microsoft releases Windows 11 22H2, formally dubbed the “2022 Update”

As predicted, Microsoft is formally releasing Windows 11 version 22H2 to the general public today. Also called the “Windows 11 2022 Update,” version 22H2 is a major update that brings a plethora of fixes and refinements to the operating system, improving the Start menu, jettisoning some more Windows 8-era user interface designs, adding new touchscreen and window management features, and more. We covered many of the new features earlier this year, when the update was still undergoing beta testing.

The rollout to Windows Update will be phased, but if you want to get your hands on the update now, you can use the Windows 11 Installation Assistant, because that makes sense.

Upcyling a 40-year-old Tandy Model 100 Portable Computer

The M100’s LCD is really 10 separate displays, each controlled by its own HD44102 driver chip. The driver chips are each responsible for a 50-by-32-pixel region of the screen, except for two chips at the right-hand side that control only 40 by 32 pixels. This provides a total screen resolution of 240 by 64 pixels. Within each region the pixels are divided into four rows, or banks, each eight pixels high. Each vertical column of eight pixels corresponds to one byte in a driver’s local memory.

The Tandy Model 100’s odd display arrangement was done to make it considerably faster, but it does mean that modernising the hardware inside the M100 today can be a but of a challenge.

The Texas Instruments TMX 1795: the (almost) first, forgotten microprocessor

The first 8-bit microprocessor, the TMX 1795 had the same architecture as the 8008 but was built months before the 8008. Never sold commercially, this Texas Instruments processor is now almost forgotten even though it had a huge impact on the computer industry. In this article, I present the surprising history of the TMX 1795 in detail, look at other early processors, and explain how the TMX 1795 almost became the first microprocessor. (Originally I thought the TMX 1795 was the first microprocessor, but it appears that the 4004 slightly beat it.)

Very detailed article about early micrprocessors, including lots of pretty pictures.

Linux optimised for 386 and 486

Do you have some old 386 or 486 machines lying around, collecting dust, but want them to become productive members of your computer household? Fret no more – there’s gray386linux and gray486linux, distributions specifically tailored for these two older architectures. I’m not entirely sure what you’d actually do with them, but fascinating projects nonetheless.

Unicode 15.0.0 adds more eyes to ꙮ

The character “ꙮ” (U+A66E) is being updated in version 15.0.0. Because it doesn’t have enough eyes. It needs to have three more eyes.

This character is rare. Very, very rare.

Rare enough to occur in a single phrase, in a single text written in an extinct language, Old Church Slavonic. The text is a copy of the Book of Psalms, written around 1429 and kept in Russia.

Basically, in some old Slavic languages, authors would stylise the “O” in their word for eye (“ꙩкꙩ”) by adding a dot in the middle to make it look like an eye. If there were two eyes, two of these characters would be joined together (“ꙭчи”). The final evolution of this character was “ꙮ”, used only once in human history, in the phrase “серафими многоꙮчитїи”, which translates to “many-eyed seraphim”.

Here’s how this relates to Unicode: the person who originally added this character to Unicode made a mistake, and didn’t count the number of eyes correctly. There should be ten eyes, not seven. This error was discovered in 2020, and now it has been corrected.

Awesome.

Running PalmOS without PalmOS

A traditional PalmOS emulator requires a ROM: a binary object that contains the original PalmOS compiled and linked for the 68K architecture. When you run an application PRC in those emulators, everything is emulated down to the hardware layer, so the ROM thinks it is talking to an actual device. Therefore, as an emulator developer, your job is to provide an implementation of the CPU, memory, display, serial port, and so on, taking into accounting the low level differences between the myriad of devices that ran PalmOS back then. As long as your implementation of the physical layer is accurate, applications will generally run fine.

PumpkinOS also allows you to run binary 68K applications, but do not require a copyrighted PalmOS ROM. The short story is this: the developers of PalmOS devised a clever way to implement system calls (also used in other 68K systems, I think). They used a feature of the 68K CPU called trap. A trap is like a subroutine call, but instead of jumping to a different memory addresses depending on the system call, it jumps to a fixed address, passing an argument identifying the system call. PumpkinOS takes advantage of this fact and, whenever a trap is issued, it intercepts the execution flow, identifies the system call, extract the parameters and calls a native implementation inside PumpkinOS, bypassing a ROM altogether. It is very similar to the way PACE (Palm Application Compatibility Environment) was implemented when PalmOS 5 was introduced. If the 68K application plays by the rules and only calls the OS through system traps, never accessing hardware directly, it will also run fine on PumpkinOS. Now, if you want to know the long version of this story, keep reading.

Even more details about the inner-workings of PumpkinOS.

An X11 apologist tries Wayland

All in all, I’m very impressed with the work the wayland community has done since I last did a serious look at the state of things. I’m still waiting for a stacking window manager that scratches the same itch for me that icewm does, but I’m following labwc with great interest. At this point though, I’ve established that I can live my life on wayland, and for the time being I am. Not everyone can yet though, and there’s still work to be done. Part of why I’m feeling the urge to transition to wayland is performance benefits, but the other part is so that I’ll be able to help solve the unsolved problems to make it viable for more people.

I don’t think X is ever going to die. Even if it fades away on Linux, there’s a lot of old video hardware that will probably only ever be well supported with real Xorg, on Linux and other OSes such as NetBSD. That stuff is already seeing support dropped in more recent versions of Xorg, and preservationists will need to do digging to find versions that still take advantage of everything the hardware has to offer. But, I understand now why the wayland folks have been talking so highly of it, and how drastically it simplifies the userland stack, and I’m no longer concerned that I’ll wake up to find my netbook has become unusable for modern software.

I’ve been on Wayland on both my laptop and workstation for a long time now, and there’s no way I’m ever going back with just how much better it performs than X.org. Only my main PC (used mostly for gaming) is still on X.org (Linux Mint), but that’s out of a combination of NVIDIA hardware and my satisfaction with Mint. I agree with the author that X.org won’t die, but the arrow of time is pointing in a very clear direction.

The $300bn Google-Meta advertising duopoly is under attack

For the past decade there were two more or less universally acknowledged truths about digital advertising. First, the rapidly growing industry was largely impervious to the business cycle. Second, it was dominated by the duopoly of Google (in search ads) and Meta (in social media), which one jealous rival has compared to John Rockefeller’s hold on oil in the 19th century.

Both of these verities are now being challenged simultaneously.

Having giants like Google and Facebook checked and balanced by competition is always a plus, but one has to wonder if this is just going to accelerate the race to the bottom in the online ad business.

Intel replaces Pentium and Celeron brands with “Processor” brand

Today, Intel introduces a new processor for the essential product space: Intel Processor. The new offering will replace the Intel Pentium and Intel Celeron branding in the 2023 notebook product stack.

Those are some old, long-standing brands Intel just put out to pasture. “Intel Processor” will exist next to the Core i product lines as budget processors, just like Pentium and Celeron do today.

Linux command line for you and me

Linux command line for you and me is a book for newcomers to command line environment.

Exactly as it says on the tin. This is a great, easy to use resource for command line use. Even though I’ve used Linux for more than two decades, and have been Linux-only for a few years now, I rarely use the command line, and having a resource like this in my back pocket for the few times I do dive into the command line is very nice – especially when you need to use some of the less obvious commands.

How clever mechanics keep 50-year-old BART trains running: Windows 98, eBay, and scraps

When BART first carried passengers, the country was sending astronauts to the moon. The Apollo-era trains were symbols of a generation barreling toward a space-age future complete with carpeted floors and a seat promised to every passenger.

That was 1972, when BART was state of the art. But half a century later, as the agency celebrates its 50th anniversary this month, many of those same silver-and-blue trains are still chugging through the Bay Area. And keeping them running — even in the country’s technology capital — requires a special breed of ingenuity.

BART mechanics rely on Frankensteined laptops operating with Windows 98, train yard scraps and vintage microchips to keep Bay Area commuters on the rails.

These stories are a dime a dozen, and serve to illustrate there’s a lot more outdated tech out there in our daily lives than we think. On the flipside, that’s some decent job security for the engineers and maintenance crew involved.

Multi-threading and globals on Pumpkin OS

The developer of Pumpkin OS (which we talked about before), a port of the Palm OS to x86-64, has written a very interesting post about dealing with multi-threading. Pumpkin OS is multi-threaded from the start, but several parts of the operating system rely on old parts of Palm OS that were never meant to be multi-threaded – such as the M68K emulator used to run Palm OS applications written for that architecture.

The solution I came up with uses something called thread local storage. Each thread has access to a private memory region that the main thread can setup in advance. When a deeply nested function needs to access global state, instead of using a global variable, it gets a pointer to its local storage. Each emulated M68K thread writes to its own M68K state, not interfering with another thread. And no function prototype needs to change. The first step was to identify all global variables used by the M68K emulator, which were surprisingly few.

I’m so excited about this project.

Adobe to acquire Figma in a deal worth $20 billion

Adobe has announced that it’s acquiring Figma, a popular design platform, for around $20 billion in cash and stock. After rumors surfaced early on Thursday about a potential acquisition, Adobe made it official in a press release shortly afterward. It’s big news in the design and development world, particularly as Figma has been competing heavily with Adobe’s XD products in recent years.

I had never heard of Figma before, but it seems it’s actually quite popular – for example, Microsoft uses it to design Office and Windows. This seems like a big catch for Adobe, but a competitor less, too, and that’s not exactly great for the market.

EU upholds Google’s 4.1B euro fine for bundling search with Android

Google has lost its latest battle with European Union regulators. This morning, the EU General Court upheld Google’s record fine for bundling Google Search and Chrome with Android. The initial ruling was reached in July 2018 with a 4.34 billion euro fine attached, and while that number has been knocked down to 4.125 billion euro ($4.13 billion), it’s still the EU’s biggest fine ever.

The EU takes issue with the way Google licenses Android and associated Google apps like the Play Store to manufacturers. The Play Store and Google Play Services are needed to build a competitive smartphone, but getting them from Google requires signing a number of contracts that the EU says stifles competition.

Google breakin’ rocks in the hot sun.