ibm

99 Articles

Open Hardware Laptop Built On Power PC ISA

August 28, 2020 by 17 Comments

Since Apple switched to Intel chips in the mid-00s, the PowerPC chips from Motorola and the PowerPC Instruction Set Architecture (ISA) that they had been using largely fell by the wayside. While true that niche applications like supercomputing still use the Power ISA on other non-Apple hardware, the days of personal computing with PowerPC are largely gone unless you’re still desperately trying to keep your Power Mac G5 out of the landfill or replaying Twilight Princess. Luckily for enthusiasts, though, the Power ISA is now open source and this group has been working on an open-source laptop based on this architecture.

While development is ongoing and there are no end-user products available yet, the progress that this group has made shows promise. They have completed their PCB designs and schematics and have a working bill of materials, including a chassis from Slimbook. There are also prototypes with a T2080RDB development kit and a NXP T2080 processor, although they aren’t running on their intended hardware yet. While still in the infancy, there are promising videos (linked below) which show the prototypes operating smoothly under the auspices of the Debian distribution that is tailored specifically for the Power ISA.

We are excited to see work continue on this project, as the Power ISA has a number of advantages over x86 in performance, ARM when considering that it’s non-proprietary, and even RISC-V since it is older and better understood. If you want a deeper comparison between all of these ISAs, our own [Maya Posch] covered that topic in detail as well as covered the original move that IBM made to open-source the Power ISA.

Continue reading “Open Hardware Laptop Built On Power PC ISA” →

Frances Allen Optimised Your Code Without You Even Knowing

August 25, 2020 by 9 Comments

In 2020, our digital world and the software we use to create it are a towering structure, built upon countless layers of abstraction and building blocks — just think about all the translations and interactions that occur from loading a webpage. Whilst abstraction is undoubtedly a great thing, it only works if we’re building on solid ground; if the lower levels are stable and fast. What does that mean in practice? It means low-level, compiled languages, which can be heavily optimised and leveraged to make the most of computer hardware. One of the giants in this area was Frances Allen, who recently passed away in early August. Described by IBM as “a pioneer in compiler organization and optimization algorithms,” she made numerous significant contributions to the field. Continue reading “Frances Allen Optimised Your Code Without You Even Knowing” →

IBM Reveals POWER10 CPU Based On The OpenPOWER ISA 3.1 Specification

August 19, 2020 by 22 Comments

This week, IBM revealed their POWER10 CPU, which may not seem too exciting since it’s primarily aimed at big iron like mainframes and servers. The real news for most is that it is the first processor to be released that is based on the open Power ISA specification v3.1. This new version of the Power ISA adds a number of new instructions as well as the notion of optionality. It updates the v3.0 specification that was released in 2015, right after the founding of the OpenPOWER Foundation.

Currently, a number of open source designs for the Power ISA exists, including MicroWatt (Power v3.0, VHDL) and the similar ChiselWatt (written in Scala-based Chisel).  In June of this year, IBM also released the VHDL code for the IBM A2 processor on Github. This is a multi-core capable, 4-way multithreaded 64-bit design, with silicon-implementations running at up to 2.3 GHz and using the Power ISA v2.06 specification.

The ISA specifications and other relevant technical documentation can be obtained from the OpenPOWER website, such as for example the Power ISA v3.0B specification from 2017. The website also lists the current cores and communities around the Power ISA.

(Main image: POWER10 CPU, credit IBM)

Ask Hackaday: Are 80 Characters Per Line Still Reasonable In 2020?

June 18, 2020 by 186 Comments

Software developers won’t ever run out of subjects to argue and fight about. Some of them can be fundamental to a project — like choice of language or the programming paradigm to begin with. Others seem more of a personal preference at first, but can end up equally fundamental on a bigger scale — like which character to choose for indentation, where to place the curly braces, or how to handle line breaks. Latest when there’s more than one developer collaborating, it’s time to find a common agreement in form of a coding style guide, which might of course require a bit of compromise.

Regardless of taste, the worst decision is having no decision, and even if you don’t agree with a specific detail, it’s usually best to make peace with it for the benefit of uniformly formatted code. In a professional environment, a style guide was ideally worked out collaboratively inside or between teams, and input and opinions of everyone involved were taken into consideration — and if your company doesn’t have one to begin with, the best step to take is probably one towards the exit.

The situation can get a bit more complex in open source projects though, depending on the structure and size of a project. If no official style guide exists, the graceful thing to do is to simply adopt the code base’s current style when contributing to it. But larger projects that are accustomed to a multitude of random contributors will typically have one defined, which was either worked out by the core developers, or declared by its benevolent dictator for life.

In case of the Linux kernel, that’s of course [Linus Torvalds], who has recently shaken up the community with a mailing list response declaring an overly common, often even unwritten rule of code formatting as essentially obsolete: the 80-character line limitation. Considering the notoriety of his rants and crudeness, his response, which was initiated by a line break change in the submitted patch, seems downright diplomatic this time.

[Linus]’ reasoning against a continuing enforcement of 80-char line limits is primarly the fact that screens are simply big enough today to comfortably fit longer lines, even with multiple terminals (or windows) next to each other. As he puts it, the only reason to stick to the limitation is using an actual VT100, which won’t serve much use in kernel development anyway.

Allowing longer lines on the other hand would encourage the use of more verbose variable names and whitespace, which in turn would actually increase readability. Of course, all to a certain extent, and [Linus] obviously doesn’t call for abolishing line breaks altogether. But he has a point; does it really make sense to stick to a decades old, nowadays rather arbitrary-seeming limitation in 2020?

Continue reading “Ask Hackaday: Are 80 Characters Per Line Still Reasonable In 2020?” →

Building A 3270 Terminal Controller

May 28, 2020 by 56 Comments

We like to talk about how most of our computers today would have been mainframes a scant 40 or 50 years ago. Because of that, many people who want to run IBM mainframes such as the IBM 360 or 370 use the Hercules emulator to run the big iron on their PCs. However, mainframe IBM computers used an odd style of terminal and emulating it on a PC isn’t always as satisfying. At least, that’s what [lowobservable] thought, so he decided to get a 3270 terminal working with Hercules.

Back in the bad old days of computing, there were two main styles of terminals. Some companies, for example DEC, essentially used terminals as a “glass teletype.” That is, the screen was an analog of a roll of paper — more or less — and the keyboard immediately sent things to the remote system. However, companies like IBM and HP favored a different approach. Their terminals dealt with screens full of data. The terminal was smart enough to let you fill in forms, edit text on the screen, and then you’d send the entire screen in one gulp. Both systems had pros and cons, but — as you might expect — the screen-oriented terminals were more complex.

Continue reading “Building A 3270 Terminal Controller” →

Can You Help 3D Print A Selectric Ball?

January 26, 2020 by 63 Comments

The IBM Selectric changed typewriters as we knew them. Their distinctive ball element replaced the clunky row of typebars and made most people faster typists. When [Steve Malikoff] thought about 3D printing a type ball — colloquially known as a golf ball — it seemed like a great idea.

The problem? It just doesn’t work very well. According to [Steve], it is likely because of the low resolution of the printer. However, it isn’t clear the latitudes of the characters are correct. and there are a few other issues. It is possible that a resin printer would do better and there’s a call for someone out there to try it and report back. We are guessing a finer nozzle and very low layer height might help on an FDM printer.

Judging from the images, it looks like some of the balls do pretty well, but don’t get a full strike at the tilt angle. So it could be something else. However, it does sound like cleaning up the print so it fits is a major problem.

The Selectric was notable for several reasons — you can see an ad for the machine in the video below. The type ball meant you couldn’t jam keys. Since you didn’t have to unjam keys and you had the ribbon in a cartridge, you would have to work really hard to get ink on your fingers, even if you used the cloth ribbon instead of the arguably better carbon film ribbon. The Selectric II could even use a special tape to lift the carbon ribbon off the paper for correcting mistakes. No white-out liquid or fussing with little strips of correction paper. The fact that the ball moves means you don’t have to clear space on the side of the machine for the platen to travel back and forth.

Can you help? If you have a Selectric I or II and a high-quality printer, this would be a fun project to try and report back your results to [Steve]. If you are familiar with the later issue typeballs, you might not have seen the wire clip that [Steve] uses to hold the ball in place. However, you can see them in the video ad below. More modern balls use a plastic lever that acts as a handle so even with cloth ribbons you have less chance of getting ink on your hands.

Although there were Selectrics meant to interface with a computer, you can refit any of them to do it with some work. The Selectric also has a role in one of the great techno spy stories of all time: The GUNMAN project.

Continue reading “Can You Help 3D Print A Selectric Ball?” →

The Barn Find IBM 360 Comes Home

December 8, 2019 by 29 Comments

It’s a story that may be familiar to many of us, that of bidding on an item in an online auction and discovering once we go to pick it up that we’ve bought a bit more than we’d bargained for. We told you earlier in the year about the trio of Brits who bought an IBM System/360 mainframe computer from the mid 1960s off of a seller in Germany, only to find in the long-abandoned machine room that they’d bought not just one but two 360s, and a System/370 to boot. Their van was nowhere near big enough for all three machines plus a mountain of cabling, documentation, and period storage media, so they moved it to a hastily-rented storage unit and returned home to work out what on earth to do next.

Now we’ve received an email from the trio with some good news; not only have they managed to bring their hoard of vintage big iron computing back home, but also they’ve found a home for it in the rather unusual surroundings of a former top-secret UK Government signals intelligence station. With the help of a friendly specialist IT relocation company they unleashed it from their temporary storage and into the truck for the UK. It’s a tale of careful packing and plenty of wrapped pallets, as we begin to glimpse the true extent of the collection as you can see in the video below the break, because not only have they secured all the hardware but they also have a huge quantity of punched cards and disk packs. The prospect of a software archaeology peek into how a 1960s mainframe was used by its original customer is a particularly interesting one, as it’s likely those media contain an ossified snapshot of its inner workings.

We’re hoping to follow this project as it evolves, and see (we hope) a room full of abandoned junk transformed into a facsimile of a typical 1960s business computing setup. If you’d like to catch up, read our original coverage of the find.

Continue reading “The Barn Find IBM 360 Comes Home” →