Perkian - Introduction

Written by Rich Morin.

Contents: (hide) (show)

Path:  AreasContentOverviews

Precis:  introduction to the Perkian Project

This page discusses Perkian, a speculative project aimed at making end-user operating systems more blind-friendly. Named after Debian, Raspbian, and the Perkins Brailler), Perkian’s initial thrust is to produce “turn-key” distributions of relevant open source software.

Note: The LightHouse Labs talk page is adapted from a short presentation I gave at the SF LightHouse in May 2019. The first part discusses Pete’s Alley; the second discusses Perkian and describes the general approach taken in Perkify.

Note: The Perkian - Index page is an informal, hand-edited index of pages on Pete’s Alley that are related to Perkian, Perkify, etc. To keep up with additions, discussions, and updates, subscribe to the Perkian mailing list at (http://perkian.groups.io).

Background

Most end-user operating systems (e.g., for personal computers or cell phones) are optimized for use by sighted users. So, for example, they rely heavily on graphical user interfaces (GUIs), which may or may not be accessible to users with visual impairments. This emphasis on GUIs starts at the desktop level and extends into most of the applications.

In addition, these systems take little advantage of the wealth of software that has been developed in the open source community. Much of this software is text-based, eliminating a large class of accessibility issues. Some packages, such as BRLTTY and Emacspeak, are specifically intended for use by the blind. The Perkian Project seeks to make these sorts of software conveniently available on a wide range of existing computers, including any packages that have a plausible argument for inclusion.

Surprisingly, the impact of including “extra” software is negligible. Terabyte-scale hard disk drives and solid-state drives are commonplace; even microSD cards can store more than a hundred gigabytes. So, even a few gigabytes of added software won’t “fill up the disk”. Also, software doesn’t use any runtime resources (e.g., CPU, I/O, RAM) when it isn’t running, so it can’t “slow the system down”. In short, there isn’t any practical limit on the amount of software that can be added and no particular reason to be parsimonious.

Adding Packages

Adding open source packages to existing operating systems can be challenging, requiring substantial amounts of effort, luck, skill, and time. One of the biggest problems is fragmentation: even if a package has been ported to the user’s operating system, there may be no well-tuned way to install it. Not surprisingly, typical personal computer users install very few open source packages. However, there appears to be a path through the wilderness, based on several observations:

By using a Linux-based virtual machine to encapsulate a suite of open source packages, we can “dance around” most issues of porting, packaging, and operating system compatibility. That is, we can create and distribute a suite of blind-friendly packages that enhances a wide range of existing systems. And, because we only have to support a single (albeit virtual) platform, the packages can be configured and tuned to work well together.

The Perkify distribution takes just this approach. A copy of Ubuntu, enhanced with dozens of open source packages, is converted into a virtual machine, using Vagrant and Virtual Box. The resulting “box” can be downloaded, installed, and run on any conventional (i.e., 64-bit, Intel-based) personal computer.

Portability

As long as a system can be convinced to run a suite of Linux software (either directly or indirectly), it’s a plausible target. However, desktop systems are inconvenient to carry around and even laptop computers have a lot of hardware (e.g., display screens) which is irrelevant for blind users. So, as a longer-term goal, I’d like to make Perkian part of a “palmtop” computer system.

Various users have different, but largely compatible criteria for a blind-friendly portable computer. Some would be happy with a simple “notetaker”, while others will want a complete computing solution. However, most users want something that’s convenient and easy to use, economical, lightweight, small, etc. It should be usable on its own, but support keyboards, etc. And a pony…

It should have a simple, menu-based interface for casual and/or naive use (e.g., playing music, taking notes, sending messages). Something like Xiki might be a useful starting point for this. However, it should also have a selection of command-line interfaces (e.g., the Bash shell, text-based commands) for expert users and/or complex tasks.

The device should “boot up” very quickly. An “always on” device would be ideal, but any continuous power drain will limit battery life. (A quiescent low-power mode might resolve this, but seems challenging to provide.) For the moment, users will need to recharge the battery on a regular basis (e.g., from an AC adaptor or a “power bank”). Alternatively, they can simply put up with the booting delay.

The Raspberry Pi and similar economical computers are tempting targets, but they are not the only interesting possibility. Billions of cell phones run Android, so all of them can run Linux applications. Many of these phones are outdated and consequently available for little money. So, I am also investigating porting the Perkify suite to these devices.

Related Work

Most personal computer operating systems (e.g., macOS, Windows) support a minimal level of accessibility. For example, they may provide screen readers, support for braille displays, etc. However, supporting visually disabled users is not their primary goal, so there is no comprehensive effort to make these systems accessible.

Several blind-friendly Linux variants do have this goal. Some are aimed at conventional (i.e., Intel-based) personal computers; others concentrate on economical (e.g., ARM-based) single-board computers. In general, these systems are based on a popular Linux distribution such as Arch or Debian. For more information, see the Related Work page.

Status

The first step is to assemble a “wish list” of plausible inclusions. As it happens, Pete’s Alley has already made a start on this. Our Software section contains several dozen items (and counting!) which would be plausible additions to a Perkian distribution. Each one is described, as usual, in its main.toml file. However, most of these items also have a make.toml file. These files, named after the Unix Make command, will eventually contain enough porting information to drive a release building tool.

For the moment, however, I’m using hand-edited TOML files to drive a Vagrant-based build process. I’ve also started a (somewhat speculative) page on implementation. Meanwhile, the Make dashboard summarizes several dozen packages. Finally, the Make Schema is available for your edification and amusement.

To be continued…