command line

29 Articles

Building A Serial Bus To Save An Old Hard Drive

June 28, 2022 by 67 Comments

Universal Serial Bus has been the de facto standard for sending information to and from computer peripherals for almost two decades, but despite the word “universal” in the name this wasn’t always the case. Plenty of competing standards, including USB, existed in the computing world in the decades before it came to dominance, and if you’re trying to recover data from a computer without USB you might have to get creative with how it’s done.

[Ben] recently came across a 80486 with this problem, so he had to get creative to recover the contents of the drive. He calls it the “lunchbox” computer due to its form factor, and while it doesn’t have USB it does have a tried-and-trusted serial port to communicate with other computers. [Ben] wrote up a piece of software for both the receiving computer and the sending computer in order to copy the drive sectors one by one across a serial link to a standalone computer running Windows XP, and was able to recover the contents of the drive that way instead.

All of the code [Ben] wrote is available on his GitHub page for anyone looking to boot up a 30-year-old computer again. While it might sound uncommon, computers of this vintage are still around running things like CNC machines or old mainframes.

Remote Screen Viewer Is Text-Only

May 31, 2022 by 5 Comments

Have you been slowly falling down a rabbit hole of Stallman-like paranoia of computers ever since installing Ubuntu for the first time in 2007? Do you now abhor anything with a GUI, including browsers? Do you check your mail with the command line even though you’re behind seven proxies? But, do you still want to play Minecraft? If so, this command-line-only screen viewer might just be the tool to use a GUI without technically using one.

This remote screen viewer is built in Python by [louis-e] and, once installed, allows the client to view the screen of the server even if the client is a text-only console. [louis-e] demonstrates this from within a Windows command prompt. The script polls the server screen and then displays it in the console using the various colors and textures available. As a result, the resolution and refresh rate are both quite low, but it is still functional enough to play Minecraft and do other GUI-based tasks as long as there’s no fine text to read anywhere.

The video below only shows a demonstration of the remote screen viewer, and we can imagine plenty of uses beyond this proof-of concept game demonstration. Installing a desktop environment and window manager is not something strictly necessary for all computers, so this is a functional workaround if you don’t want to waste time and resources installing either of those components. If you’re looking for remote desktop software for a more specific machine, though, take a look at this software which enables remote desktop on antique Macs.

Continue reading “Remote Screen Viewer Is Text-Only” →

IBM PalmTop Running Modern (Modified) Linux

February 6, 2022 by 19 Comments

The handheld computing market might seem dominated by smartphones today, but before their mass adoption there were other offerings for those who needed some computing power on-the-go. If a 90s laptop was too bulky, there was always the IBM PalmTop which packed punch for its size-to-weight ratio, and for the era it was created in. [Mingcong Bai] still has one of these antiques and decided to see if it was still usable by loading a customized Linux distribution on it.

The PalmTop sported modest hardware even for its time with an Intel 486SL running at 33 MHz with 20 MiB of RAM. This one also makes use of a 1 GB CompactFlash card for storage and while [Mingcong Bai] notes that it is possible to run Windows 95 on it, it’s not a particularly great user experience. A Linux distribution customized for antique hardware, AOSC/Retro, helps solve some of these usability issues. With this it’s possible to boot into a command line and even do some limited text-based web browsing as long as the Ethernet adapter is included.

While the computer is running at its maximum capacity just to boot and perform basic system functions, it’s admirable that an antique computer such as this still works, especially given its small size and limited hardware functionality. If you’re curious about more PalmTop-style computers, take a look at the first one ever produced: the HP-200LX.

Continue reading “IBM PalmTop Running Modern (Modified) Linux” →

A Collection Of Linux Tools On Steroids

June 21, 2021 by 75 Comments

Sometimes we do things because “that’s the way we’ve always done them.” Screws, for example, had slotted heads in the 1500s and slotted heads are notoriously bad, but despite Robertson in 1907 and Phillips in the 1930s, it took decades for slotted screw heads to become uncommon and they still lurk in a few areas. Many Linux tools we use every day are direct descendants from Unix tools that have been around for almost half a century. We’ve looked at a few more modern alternatives before, and [ibraheemdev] has a GitHub collection of many such tools that’s worth checking out.

Of course, modern doesn’t always mean better. However, the tools in the list do have great features including things that were uncommon in the old days such as the use of color, text-based graphics, and things like git integration.

Continue reading “A Collection Of Linux Tools On Steroids” →

Linux Command Line Productivity With Tmux

May 1, 2020 by 23 Comments

It is no secret that most Linux power users use the shell for many tasks, as for people who know what they are doing, it can be quite efficient. In addition, there are some tasks that can only be carried out from the command line, although their number shrinks every year. However, these days we are spoiled because you can have one X session running lots of terminals at once. If you log into a server, it might not have X. Or you might log into a computer over a slow connection where X is painful to use. What then? The modern answer is the tmux terminal multiplexer, and [zserge] has a thoughtful introduction to how you can use tmux for improved productivity at the command line.

In particular, he shares some configuration and offers sound advice. For example, do you really need a status bar that shows you CPU load at all times? Cool, yes, but not always a practical win.

Continue reading “Linux Command Line Productivity With Tmux” →

Sweet Streams Are Made Of These: Creating Music On The Command Line

March 19, 2020 by 3 Comments

There are countless ways to create music. In the simplest form, it won’t even require any equipment, as evidenced by beatboxing or a capella. If we move to the computer, it’s pretty much the same situation: audio programming languages have been around for as long as general-purpose high-level languages, and sound synthesis software along with them. And just as with physical equipment, none of that is particularly necessary thanks to sed. Yes, the sed, the good old stream editor, as [laserbat] shows in her music generating script.

Providing both a minified and fully commented version of Bach’s Prelude 1 in C major as example, [laserbat] uses a string representation of the sheet music as the script’s starting point, along with a look-up table of each transformed note’s wavelength. From here, she generates fixed length PCM square wave signals of each of the notes, to be piped as-is to the sound card via ALSA’s aplay or SoX’s play. To keep things simple enough, she stays within the region of printable characters here, using space and tilde as low and high values respectively, providing highest possible volume at the same time this way.

The concept itself is of course nothing new, it’s how .au and .wav files work, as well as these little C lines. And while the fixed note duration takes away some of the smoothness in [laserbat]’s version, adding variable duration might just be a hint too much for a sed implementation, although we’ve certainly seen some more complex scripts in the past.

[via r/programming]

Open-Source ARM Development Simplified

March 17, 2020 by 12 Comments

The ARM series of processors are an industry standard of sorts for a vast array of applications. Virtually anything requiring good power or heat management, or any embedded system which needs more computing power than an 8-bit microcontroller is a place where an ARM is likely found. While they do appear in various personal computers and laptops, [Pieter] felt that their documentation for embedded processors wasn’t quite as straightforward as it could be and created this development board which will hopefully help newbies to ARM learn the environment more easily.

Called the PX-HER0, it’s an ARM development board with an STM32 at its core and a small screen built in. The real work went in to the documentation for this board, though. Since it’s supposed to be a way to become more proficient in the platform, [Pieter] has gone to great lengths to make sure that all the hardware, software, and documentation are easily accessible. It also comes with the Command Line Interpreter (CLI) App which allows a user to operate the device in a Unix-like environment. The Arduino IDE is also available for use with some PX-HER0-specific examples.

[Pieter] has been around before, too. The CLI is based on work he did previously which gave an Arduino a Unix-like shell as well. Moving that to the STM32 is a useful tool to have for this board, and as a bonus everything is open source and available on his site including the hardware schematics and code.