Hello there! We really hope you enjoy what you read here today! However, if it’s not too much trouble, we’d really appreciate it if you let us know what you thought of this post, through either leaving a like or dislike below, depending on if you enjoyed it or not.
It just takes a click, and it’ll really help us find out what content our readers enjoy the most.
We’re really grateful for all the support! ✨
Hello everyone, and welcome to the start of a new exciting Technology series, which aims to retell the history and development of graphical operating systems in personal computers, starting from the Alto Operating System found on the Xerox Alto, all the way up to modern ones. Hopefully, these articles will spark some curiosity about these operating systems, and help you broaden your horizons beyond the commonly known ones such as Windows, Linux, and MacOS. Enough about this, and let’s get started!
I’ve always been fascinated by computers, and even at a young age, I would try to climb chairs and desks so that I could see my dad using his Windows XP machine, and I looked so attracted by it that dad always says I almost seemed to “absorb” any single detail of what was going on on the screen. Needless to say, my fascination for computers hasn’t dried over the years and, as with many other equivalent topics, I’ve found myself drawn to the history and development of computers, especially the part which I thought represented the overall experience the most, operating systems. Despite not having studied programming or anything of the sort, I’ve still tried to learn as much as I could over the years, though, as you can imagine, I still lacked much knowledge of the less common systems.
Recently, a fateful encounter on YouTube proved to be crucial for my personal computing research, being the wonderful channel named Michael MJD, where you can find videos about a wide range of computing-related topics, even the most obscure ones; thanks to that channel, I quickly understood that there were so many wonders beyond what I knew. Though, most importantly, the one series of videos that, I can say, ultimately gave birth to this GUI Wonderland series of mine was their Windows Development series, especially the videos about Windows 95 and Windows Longhorn[1]; I was extremely captivated by how much these systems changed over the time, the features they tried and then discarded, and what they took from other operating systems or graphic environments of the time. Thus, I absolutely knew I had to write something along those lines, not only for Windows systems but for every other intriguing OS and GUI too!
As you can imagine, it took some time to get myself acquainted enough with these topics to be able to research and write about them; you see, I feared I didn’t have some of the technical knowledge required to understand some difficult passages, though now I do, and the time has finally come!
Thus, today, in the first episode of this series, we’ll be covering a special system that strove to make the Graphical User Interface into its fundamental basis instead of regarding it as a simple accessory, thus revolutionizing computer history as a whole.
Before moving on with that, let me ask you a question; can you imagine a time when, on a computer, you could only operate with abstract-looking text-based commands instead of using simple menus, and it was unheard of to use the oh-so-common device we call the mouse? A time when computers were harder to learn, and even harder to master; a time when your good memory and availability of a lengthy manual were crucial to using a computer, and when regular people would be almost afraid of them or unable to use them in their daily lives due to their innate abstractness. Now, can you appreciate how influential and groundbreaking a Graphical User Interface (GUI) ultimately ended up being? If now most of us are proficient at computers, or at least able to use them effectively, it’s thanks to the immediately approachable GUIs in our systems.
Though, you may be wondering, is that perhaps a recent achievement, or do we need to rewind the clock hands a bit more to find out? Well, you might be surprised to know that we’ll need to go far back, to the year 1973, when a special machine was introduced for the first time…
| Xerox Alto |
|---|
| Introductory Price | US$32,000 in 1979 (equivalent to $135,204 in 2024) |
| CPU | TTL-based. User-programmable microcode. CPU clock of 5.88 MHz. |
| Memory | 96 – 512 KB (128 KB for 4000 US$) |
| Display | 606 × 808 pixels |
This is a personal computer developed by Xerox’s PARC (Palo Alto Research Center), and it was first introduced in 1973, at a time when that same Xerox meant only “copy”, and IBM was an extremely important PC manufacturer; among all the features it had, what is probably its most influential achievement is that it was purposely built to run a GUI operating system, the Alto Operating System, at a time when something like that was unheard of. Unfortunately, you could not buy one, as it ended up not being a commercial product[2], though it was still widely used at PARC itself and was also employed at other facilities such as the White House, the U.S. House of Representatives, Stanford University, and so on; despite being not so widespread, Xerox still produced an amount of approximately 2000 units.
With the Xerox Alto, they wanted to achieve something called the “office of the future”, no matter how long it would have taken, and for that, they needed a personal device that was small enough to be used in an office, yet capable of many complex tasks despite its small size; though, most importantly, on top of those features, the machine had to be both interactive[3] and easy enough to learn by anyone, even by novice users. In order to make such a dream a reality, PARC had to take inspiration from already existing projects that were exploring those possibilities, such as the NLS (oN-Line System) research program established at the Stanford Research Institute. SRI suggested the use of a raster[4] CRT display, plus their NLS was the first system to employ a mouse, hypertext links, screen windowing, and many more concepts that we take for granted in today’s computing.
The Mouse
One of the various aspects Xerox took from NLS is the mouse, which had to be licensed in 1971 from SRI themselves so that Xerox could use it in their systems; even though it was not so distinct from what we call a mouse, the Xerox Alto incarnation was still different enough, as it was nothing other than a rectangular box-shaped device with three inter-connected big black buttons which were particularly thick and rectangular-shaped.
In order to make it work, at first, they used two perpendicular wheels to track movement; after some time, they were quickly replaced by more advanced versions with improved tracking methods. These newer editions, like many vintage mice, registered movement thanks to a steel ball placed in its bottom part, which apparently used to cause quite some issues; in fact, according to a certain Geoff Thompson (who worked at PARC from 1972 to 1981), they used to pick up dirt, get clogged, and stop tracking, so the developers would often leave their dead mouse in a specific box and retrieve a working one in exchange. Later on, Xerox started using optical mice instead, that weren’t prone to this kind of issue.
Even if it looked a bit different, though, this Xerox Mouse’s underlying logic was incredibly similar to today’s mice, as you’d select with the leftmost button, and call a context menu with the rightmost button; on the other hand, the center button offered yet more options to choose from, unlike modern mice where if an equivalent button exists, it usually has other purposes.
However, what if you wanted to operate this computer in a way that didn’t involve a mouse or keyboard? Lucky you then, as Xerox Alto users could opt for a special chorded keyboard, the Alto Keyset, which resembled a small piano keyboard with 5 keys; unfortunately, it never became popular, as users preferred to use a mouse instead.
Appearance
Another aspect that would look bizarre today but was impressive at the time is its overall size, as it was housed in a relatively small cabinet, on top of which you could easily put your black and white CRT monitor, mouse, and detachable keyboard; what’s even weirder, though, is the fact that the screen orientation was portrait and not landscape. If you think about it, it’s not too absurd, as it was a machine meant to work on documents and reports, and such documentation is usually printed on portrait-oriented paper; for this same reason, the screen displayed text in black over a white background, to be more resemblant to the actual documents found in offices, as well as to be more comfortable to read.
A fact I found surprising is that the Alto’s keyboard recognized multiple button presses at a time and, depending on which ones you pressed simultaneously, you’d be able to boot different OSes found on its hard disk; apparently, some developers went a bit overboard with the required buttons, giving birth to the so-called “nose boot”, which happened when the user would run out of fingers to keep all those buttons pressed at the same time and had to rely on other body parts, such as their nose. Even though it must have been quite hilarious to see, it was later fixed by a program that let you overrule the needed sequence of keys.
Network Capabilities?!
Surprisingly enough, Altos had network capabilities, and could rely on the Ethernet (also invented by Xerox) to communicate with each other; plus, you could connect printers and file servers to the network, and the Alto even had e-mail programs (Laurel and Hardy) that worked over the Ethernet! Plus, if you wanted to be less productive, you had the option to challenge everyone on your same network to an addicting game of Alto Trek (more on that later on).
However, before starting your well-deserved game of Alto Trek, you had something to consider in order to set up your network; how would you properly tell apart all the various Altos connected together on the same network? To do so, you could have chosen between two options; for example, you had the chance to assign a unique Ethernet Address to each Alto, something similar to “50#100”, which would be simple to come up with, yet certainly hard to remember. So, what about a more “memorable” option? Fortunately for Alto users, it was possible to assign an actual proper name to each machine, and as a result, you could forget about your cryptic Ethernet Address; these machines’ owners seemed to have so much fun at coming up with names that they decided to follow a different theme for every place where Altos were in use. For example, the ones at Stanford took inspiration from rivers and mountains found in California State parks, and the ones at Xerox were named after famous people.
Though, what if you wanted to do something that went beyond the capabilities of the single Altos, and needed some other functions, such as a printer? Was it even possible for a network to share a printer at the time? As you might have expected, it was indeed possible, and Alto users knew the comfort of sending a file to a printer in the next room and having it taken care of, at a time when something like that was quite incredible. Yet, that was not all! Another feature Alto users could take advantage of was a File Server, where they could store files that were either too large to fit on their personal Alto or that were rarely needed, and freely access them from any machine they wanted; as you can see, the Xerox Alto wasn’t certainly groundbreaking only for its GUI, and whoever had the chance to use it at the time must have found it incredible and, without any doubt, quite convenient.
Software
Now, it’s time to finally mention all the outstanding features that this machine had software-wise! First of all, its operating system was constituted by GUI programs, starting from its file manager, called Alto Neptune; to control this program, you had the chance to use both your mouse (each button had a specific function, such as “Copy”, “Rename”, or “Delete”) and some graphical buttons on the screen, though the program was still far from what we’re used to nowadays, due to the lack of icons and pictures. On the other hand, one of is features that was similar to our file systems nowadays is the possibility of naming your files with longer names; it might sound incredible to some users now, but many systems at the time limited the characters that could fit into a file name to six or eight characters with a three-character extension, so I’m certain you can see the issues of such a limitation. Conversely, the Alto file system allowed you to insert up to thirty-nine characters in a file’s name (plus the punctuation characters +-.!$ and no blanks), and allowed for longer extensions as well; plus, you could finally use lowercase characters in your file names, which increased readability.
Unexpectedly, we could say that this all sounds amazing in theory, though a bit less in practice; with those long file names you could appoint, you’d now perhaps find it tricky to fully type a file name in the command line to use it, so how did they solve this? Fortunately, there were some special tricks to have the Alto finish typing the file names for you; in fact, if you typed enough characters for the Alto to know for certain what file you wanted, and then pressed Escape, the Alto would fill in the rest of the file’s name for you. Plus, there was also a shortcut for when you didn’t want to type all the characters needed for the previously mentioned method; to use this, you just needed to add a question mark after what you typed, and the Alto would show all the files that matched what you wrote. What was amazing about such an environment was that you had something similar even for files stored on your local network, so that you didn’t have to give up on your convenience when accessing files not on your personal Alto.
Some programs
Now that we have seen how it handled single files, what about its programs? Besides its file manager, the Alto had multiple available programs, each with its own GUI, so that you could control them with your mouse; what was special about all of these is that they followed a certain idea called WYSIWYG (What You See Is What You Get), which meant that every option had to be displayed on the screen, readily available to the user, and there could be no hidden surprises or commands. Thus, there was no need to remember any commands, given that you knew where they were placed on the screen, much like most programs we use nowadays. In addition, they could even be opened in multiple windows along with other different programs, for your multitasking needs!
One of the most important pieces of software for the Alto was called Bravo, the first WYSIWYG document editor, developed by Butler Lampson, Charles Simonyi, and their colleagues; by taking advantage of the portrait-oriented screen, you could display documents that looked exactly as they would when you printed them[5], and you had a decent amount of fonts and text formatting options you could choose from. Plus, if you needed to, you could even open more than one file at a time, each in its separate window! Unlike other programs of this system, some commands required the use of a keyboard or could be executed with both the mouse and the keyboard; an example of this is adding or deleting words inside a paragraph, as you would simply point your mouse to the exact point you needed to change, and then use the keyboard for the desired commands.
While this ease of editing sounds certainly convenient, what if you made a mistake and then didn’t notice it until later, or didn’t know how to undo a recent change? Luckily, Bravo would remember all your edits and could reverse them if required, much like the word processors we use today.
Now that we know how Bravo works, let me reveal something surprising; sometime after its introduction, Bravo was rewritten by certain individuals at PARC, thus becoming BravoX. What you probably wouldn’t imagine is that one of the people behind this, Charles Simonyi, later joined Microsoft and led the development of Microsoft Word, and this means it can be considered a direct descendent of BravoX! With this revelation, I bet you can see just how many things we take for granted today come from this same Xerox Alto, and why it’s such a fascinating system, can’t you?
Moving on, we can also have a look at Alto’s painting program, simply called Draw; similarly to Bravo, it also displayed all its commands on the screen and had a four-section layout that allowed you to separate what you were drawing from both the available commands and messages that were displayed by the program. Unlike what we’d imagine, in Draw you would mark points on the canvas using your mouse, and the program would mathematically draw the corresponding shapes for you. However, what if you needed to move a shape across the screen? Unlike programs like Paint for Windows, each shape was treated as a different object and could be individually selected and then moved around; this also applied to other actions such as rotating, shrinking, or duplicating a shape, so it seemed to be quite convenient to use.
Smalltalk, a GUI environment
One of the most impressive pieces of software that could run on the Alto, though, was called Smalltalk; it was an interactive object-oriented programming language and GUI environment, with its pop-up menus, windows, and certain small images that were later renamed “icons”. Smalltalk succeeded in showing how powerful all of the features that had been newly invented at PARC were, such as multitasking and the use of a mouse, and it marked a moment when computers finally started becoming easy to learn; in fact, the first large program to be written in Smalltalk, Pygmalion (which was actually a doctoral thesis project by a certain David Smith), wanted to show just that, and it suggested that programming could have been achieved with methods other than text input. Plus, it also wanted to show another remarkable feature that would help programming; you’d be able to show the computer what to do and it would remember and reproduce your actions. Finally, Pygmalion also offered other suggestions, such as the use of icons, so I’d say it ultimately sounds like it was an extremely exceptional thesis! After working on this project, Smith went to work on the NLS Project mentioned before, and eventually joined the development of the Xerox Star, the successor to the Alto.
Apart from revolutionizing GUIs on its own, Smalltalk has one more merit; in fact, when Steve Jobs visited PARC during the development of the Apple Lisa, he saw a demonstration of this very piece of software, presented by Larry Tesler (who worked on Smalltalk and the Gypsy word processor, the successor to Bravo) and thought it would undeniably change the world of computing forever (which is definitely true). Afterward, he decided to implement some of the features from Smalltalk into the Apple Lisa; though that will be a tale for a future episode of this series.
After the Alto
While the Alto ended up not being marketed, it still served as the basis for Xerox’s following projects; another section of Xerox, called SDD, went on developing the Star series of workstations, with systems such as the 8010, followed by a more affordable version under the 6085 Office System name. These were actually marketed, thus more users were finally able to utilize all the innovations introduced by the Alto; even so, it was too late, as Apple had already succeeded in marketing those innovations not long after seeing Smalltalk in action (we’ll go over these events with more detail in a future episode, and see what the Xerox Star was like). This eventually led Xerox to abandon the workstation market, giving up on something they could have been incredibly proficient at; who knows what could have happened if Xerox managed to make its systems successful?
I guess the most we can do now is remember these machines and projects and spread awareness of their outstanding potential and innovations; in fact, did you know that the developer of Smalltalk, Alan Kay, used some of his research later leading to Smalltalk as a basis for a “notebook”-like computer, called Dynabook? Too bad that the technology required to build it was unavailable at the time, and as a result that idea became the Alto itself. Even so, it’s honestly impressive to see just how many projects stemmed from and around the Xerox Alto, and I would absolutely love to talk more about them in the future (you’ll be glad to know that some of the machines that were inspired by the Alto, the Sun Microsystem ones, will be certainly covered in a future episode of these series).
Now that you know what a Xerox Alto is, in case you want to see one of these legends with your own eyes, you can visit the Computer History Museum in Mountain View, California, or the Computer Museum of America in Roswell, Georgia. However, if you want to see one actually running, you’ll have to go to the System Source Computer Museum in Hunt Valley, Maryland, as it’s the only place I found where you can see them in such a state… until they last. On the other hand, if you are simply curious about its code, you’ll be happy to know that both its source code and other resources are available digitally at the Computer History Museum.
Finally, you can have a look at the Further Reading section at the end of this article!
… But wait, don’t leave this page just yet, as it’s finally gaming time! Can we even game on the Alto? Will we be able to take advantage of its network capabilities?
| Gaming on the Alto |
|---|
MazeWar
The first Alto game we’ll quickly mention is called MazeWar; it wasn’t originally released for this computer, but it was instead ported from another computer called Imlac, which featured intriguing vector-based graphics. What was special about this game is that, just like Alto Trek, it was a multiplayer game, and could be played against people on the same network; luckily for the busy researchers of PARC, it was easy to jump in and out of the game without disturbing anyone, as each instance of it ran on every Alto independently, and it would connect to the network only when it needed to exchange data with other players (so, for instance, the person who started the game, the host, could leave at any time, and the MazeWar match would simply continue).
While I wouldn’t mind trying this game out, as it looks incredible for the time, the one I’d love to play the most is the following one, the impressive and deep…
Alto Trek
This is a Space Simulation RTS game developed by graduate students Gene Ball and Rick Rashid, released in 1978; just like MazeWar, Alto Trek is a networked multiplayer game, one of the very first of its kind. Though, how did it play exactly?
Each computer piloted its own starship in a giant galaxy, and the player could freely fly around, teleport to other stellar systems, destroy their enemies, and set and conquer bases; even if technically there was a single-player option, the game was supposed to be played in multiplayer, otherwise you’d have no enemies on the map. In order to win an Alto Trek match, you had two ways; either destroy every opponent along with their bases without being destroyed first, or become something called “The Master of the Universe” (which entails setting a base in every stellar system of a galaxy). In case you succeeded in the latter, the game would reward you with some interesting lines, such as “Lord of all Creation” and, as its guide reveals, “other suitably ego-inflating things”.
Aside from the humor in its guide, something that surprised me about this game is how deep and complex it is; firstly, you had three types of spaceships to choose from, and each had its own advantages and disadvantages, with Terrans being the most balanced of the three. Moreover, the game didn’t leave you alone in figuring out your ship status or anything of the sort, as your screen was neatly divided into squares that housed various features such as maps, detailed status screens along with a few on-screen buttons, and, quite incredibly, a chat for sending short messages to all the other players! As the official guide suggests, though, it is not always a smart idea to send a message, as your ship type, location, and initials of your name will be broadcast along with it and, as a result of your message, your opponents might want to come and get you. 🙂
Something else that is quite incredible and amusing at the same time is the “official strategy guide” itself (the same humorous one we mentioned before), which not only describes in detail the complex rules and features of this game, but also describes its bugs, or “features”, as the author of our trusty guide calls them (to quote one of the best ones; “Due to a “feature” of the program, some bases are unkillable.”); in case you find part of this quote somewhat familiar, perhaps you’ll have seen a meme describing glitches with “it’s not a bug, it’s a feature”, which is often used to joke about various hilarious bugs that would need to be solved.
Bugs aside, you will certainly have noticed that this was an incredible game for the Xerox Alto, especially if you remember that it wasn’t meant to be sold in stores; it’s unfortunate that we can’t really play this anymore, unless we find multiple working Altos and connect them all via Ethernet. I wonder if there’s a way to emulate all of this via MAME, though I doubt it[6]. Fortunately for us and whoever wouldn’t mind trying something similar, you’ll be glad to know that in 1997 this game was repurposed by the same Rick Rashid on Microsoft Windows, and it became Microsoft Allegiance. Who knows, I might cover it on here and see how close it is to Alto Trek!
If you’re still curious about this game, I recommend you read that famous guide we mentioned so many times; you can find it here or by browsing the Further Reading section below!
| Conclusion |
|---|
As someone who didn’t know this computer existed until not so long ago, it was extremely surprising to find out about all it did for computer history; to think that so many features that we take for granted actually originated from the Alto itself! Hopefully, you’ll have found this intriguing as well.
That said, I hope you enjoyed reading this, and I hope you’ll be looking forward to us progressing our marvelous voyage in GUI Wonderland with our next episode, where we’ll be covering the Xerox Star and the Apple Lisa!
This site, and all the content on it, is for entertainment purposes only.
Additionally, we try to provide a link to all content we use that originates from outside sources, but if we have missed a credit anywhere, then please let us know and we would be happy to rectify the issue immediately.
All rights and credit go directly to its rightful owners. No copyright infringement is intended. Please support the official release.
More available at:
If you enjoy what we’re posting, but don’t want to have to make a WordPress Account to follow us, then please feel free to have a look at our Social Media pages. If you follow us on any of these platforms, then you’ll be able to keep up with our new posts as soon as they’re available.
| Don’t have Social Media? |
|---|
Or, if you don’t have Social Media, then you can also follow us through the site itself, in which case you’ll be sent an email every time we post something. |
References
- Wikipedia: Xerox Alto – https://en.wikipedia.org/wiki/Xerox_Alto
- Wikipedia: Alto Trek – https://en.wikipedia.org/wiki/Alto_Trek
- Wikipedia: History of the graphical user interface – https://en.wikipedia.org/wiki/History_of_the_graphical_user_interface
Xerox Alto
- ToastyTech: Xerox Alto – https://web.archive.org/web/20231209043414/http://toastytech.com/guis/alto.html
- DigiBarn: Xerox Alto Operating System And Alto Applications – https://web.archive.org/web/20230704110611/https://www.digibarn.com/collections/software/alto/index.html
- Pc Museum: Xerox Alto computer – https://web.archive.org/web/20240104164030/https://pcmuseum.tripod.com/alto.html
- Netclique: The Xerox Mouse – https://web.archive.org/web/20100810061459/http://www.netclique.net/oldmouse/mouse/xerox/alto.shtml
- YouTube: Xerox Alto Restoration Part 17 – Xerox Alto Demo https://youtu.be/9H79_kKzmFs?si=0ZTqcB5emQMx54uO
- Spies: The Alto Archive – http://web.archive.org/web/20030605134216/http://www.spies.com/~aek/alto/index.html
- History Computer: Xerox Alto Complete History – https://web.archive.org/web/20201205082025/https://history-computer.com/ModernComputer/Personal/Alto.html
- GUIdebook: The Xerox Alto Computer – https://web.archive.org/web/20240106151251/https://guidebookgallery.org/articles/thexeroxaltocomputer
- Wikipedia: NLS (computer system) – https://en.wikipedia.org/wiki/NLS_(computer_system)
- Fumbling the Future: How Xerox Invented, Then Ignored, the First Personal Computer by Douglas K. Smith, Robert C. Alexander – 1988 William Morrow & Co – ISBN 9780688095116
Pictures
- Xerox Alto – https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fcdn.arstechnica.net%2Fwp-content%2Fuploads%2F2016%2F06%2F11400989606_a7964d27bb_k-980×653.jpg&f=1&nofb=1&ipt=fff116fb936575e94e59bd7737db8e21b5434e33a72c9d7152f7ed657b644edd&ipo=images
- Xerox Alto – https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Flh3.googleusercontent.com%2F-XdAjeYH_HpE%2FV2DY0-N-JdI%2FAAAAAAAA3mI%2Flai6HE5jHV8ghxBxUcogcjdZsKyv6MirQCHM%2Fs9999%2Falto.jpg&f=1&nofb=1&ipt=ffff3cfd7d6cda93c698b10fdc50f8ef9715188a1412550adca2b2e6648afd5d&ipo=images
- Xerox Alto – https://external-content.duckduckgo.com/iu/?u=http%3A%2F%2Fvintagecomputer.net%2Fvcfmw-ECCC_2010%2FXerox_Alto-II-XM%2FXerox_AltoII.JPG&f=1&nofb=1&ipt=1b13f230c2fe879ff2e597a1c720428c216ffee06f8b1fa1e4d5722eaa07148b&ipo=images
- Xerox Alto – https://nat.museum-digital.de/data/owl/images/201410/20103258906.jpg
- Xerox Alto Ethernet – https://lh3.googleusercontent.com/-712b_d9p27I/WlUGXmoQFQI/AAAAAAABIFY/O6EvBz43QdIGHsLDwRGEv6u6-hj8ICnWACHMYBhgL/w9999/inside-transceiver.jpg
- Bravo and Draw https://cdn.arstechnica.net/wp-content/uploads/2016/06/bravo.alto-copy.jpg
- Xerox Star – https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fwww.neoteo.com%2Fwp-content%2Fuploads%2F2013%2F07%2FCE45-758×733.jpg&f=1&nofb=1&ipt=22b0f80a8b08d5ebc61a96e8e2ed430c6a6597771bd25ecd33a6ecaa95bc6fea&ipo=images
- System Source Computer Museum in Hunt Valley, Maryland By Bobroswell – Own work, CC BY-SA 4.0 – https://commons.wikimedia.org/w/index.php?curid=112518480https://en.wikipedia.org/wiki/System_Source_Computer_Museum#/media/File:System_Source_Museum_wide.png
- Windows 95 – https://www.youtube.com/watch?v=sz5pE2muRWI
- Windows Longhorn – https://www.youtube.com/watch?v=lkX3ehgTsFE
- IRIX – https://www.solvusoft.com/file-extensions/images/software/large/2818_irix.png
Footnotes
- A project that should have been Windows Vista, though, at some point in development, it was decided to scrap the existing code and restart from scratch, leaving many of the existing features unused. ⤴
- Even if it wasn’t marketed, the Alto was actually the first personal computer to receive a commercial of its own, in 1979; it showcased Bill, a smiling middle-aged executive, performing his daily tasks thanks to Fred, his Alto, and we can see various of the incredible functions the machine had, such as networked printers and the ability to send files to other Altos on the network, among others. ⤴
- People wished computers were interactive because, at the time, they all operated in batch processing; this meant that you would write your code on special paper tapes, which were then run through a printer, proofread, and then, finally, given to the official operators. They’d schedule a specific time to give you your results back, and it was very possible that you’d get them days after you had written your code. If it sounds insane to you, worry not, as people at the time thought so as well. ⤴
- At the time, using raster screens in a personal computer was quite expensive, though the other available technologies, such as vector (or calligraphic) displays were not fast enough to draw all the letters and symbols found in a document. For this reason, they had to find a cheaper way to use a raster display. ⤴
- Before Bravo was invented, in order to format your text, you’d have to add special code in between words, so what you saw on the screen ended up looking different from what you’d get on paper. Then, you fed your code to a particular program called “document compiler”, and you’d finally see the end results. ⤴
- I’ve seen there is a way to emulate a revision of the Alto, the Alto II, but I have no idea if it’s possible to play networked Alto Trek on it. ⤴
Further Reading
- Archive.org: xerox alto games: trek21 – https://archive.org/details/bitsavers_xeroxaltog_698052
- Archive.org: Alto User’s Handbook – https://archive.org/details/alto-users-handbook
- Computer History: Xerox Alto source code – https://xeroxalto.computerhistory.org/xerox_alto_file_system_archive.html
- Pygmalion, a Creative Programming Environment – https://apps.dtic.mil/sti/pdfs/ADA016811.pdf
- Archive.org: Xerox Alto Memo Why – https://archive.org/download/applelisadocsandmedia_dtc/APPLE%20SYSTEM%20INFO%20-%20LISA/Xerox%20Alto%20and%20Star%20info/XeroxAltoMemoWhy.pdf
- Archive.org: Xerox Alto and Star info – https://archive.org/download/applelisadocsandmedia_dtc/APPLE%20SYSTEM%20INFO%20-%20LISA/Xerox%20Alto%20and%20Star%20info/
- Archive.org: BYTE Vol6 n8 – https://archive.org/download/BYTE-MAGAZINE-COMPLETE/198108_Byte_Magazine_Vol_06-08_Smalltalk.pdf
- Fumbling the Future: How Xerox Invented, Then Ignored, the First Personal Computer by Douglas K. Smith, Robert C. Alexander – 1988 William Morrow & Co – ISBN 9780688095116
- Dealers of Lightning: Xerox PARC and the Dawn of the Computer Age by Michael A. Hiltzik – 2000 Harper Business – ISBN 9780887309892
The Blisscast Journal 
Re: Ethernet Address to each Alto, something similar to “50#100”
That’s an 8-bit network number and an 8-bit host address. The original 3 Mb ethernets had an 8-bit host address (rather than the 48-bit ones we use today). The ethernet itself doesn’t have a “network number”, which is a concept from the next level up protocol – PUP (PARC Universal Packet), where packets are addressed with an 8-bit network number, 8-bit host number, and 32-bit port number.
Check out https://bitsavers.computerhistory.org/pdf/xerox/ethernet_3mb/Practical_Considerations_in_Ethernet_Local_Network_Design_Feb1980.pdf
LikeLike