'altair' Episodes

The Altair 8800

     9/19/2019

Welcome to the History of Computing Podcast, where we explore the history of information technology. Because understanding the past prepares us for the innovations of the future! Todays episode is on Agile Software Development. Agile software development is a methodology, or anti-methodology, or approach to software development that evolves the requirements a team needs to fulfill and the solutions they need to build in a collaborative, self-organized, and cross-functional way. Boy, that’s a lot to spit out there. I was in an elevator the other day and I heard someone say: “That’s not very agile.” And at that moment, I knew that I just couldn’t help but do an episode on agile. I’ve worked in a lot of teams that use a lot of variants of agile, scrum, Kanban, scrumban, Extreme Programing, Lean Software Development. Some of these are almost polar opposites and you still hear people talk about what is agile and if they want to make fun of people doing things an old way, they’ll say something like waterfall. Nothing ever was waterfall, given that you learn on the fly, find re-usable bits or hit a place where you just say that’s not possible. But that’s another story. The point here is that agile is, well, weaponized to back up what a person wants someone to do. Or how they want a team to be run. And it isn’t always done from an informed point of view. Why is Agile an anti-methodology? Think of it more like a classification maybe. There were a number of methodologies like Extreme Programming, Scrum, Kanban, Feature Driven Development, Adaptive Software Development, RAD, and Lean Software Development. These had come out to bring shape around a very similar idea. But over the course of 10-20 years, each had been developed in isolation. In college, I had a computer science professor who talked about “adaptive software development” from his days at a large power company in Georgia back in the 70s. Basically, you are always adapting what you’re doing based on speculation of how long something will take, collaboration on that observation and what you learn while actually building. This shaped how I view software development for years to come. He was already making fun of Waterfall methodologies, or a cycle where you write a large set of requirements and stick to them. Waterfall worked well if you were building a computer to land people on the moon. It was a way of saying “we’re not engineers, we’re software developers.” Later in college, with the rapid proliferation of the Internet and computers into dorm rooms I watched the emergence of rapid application development, where you let the interface requirements determine how you build. But once someone weaponized that by putting a label on it, or worse forking the label into spiral and unified models, then they became much less useful and the next hot thing had to come along. Kent Beck built a methodology called Extreme Programming - or XP for short - in 1996 and that was the next hotness. Here, we release software in shorter development cycles and software developers, like police officers on patrol work in pairs, reviewing and testing code and not writing each feature until it’s required. The idea of unit testing and rapid releasing really came out of the fact that the explosion of the Internet in the 90s meant people had to ship fast and this was also during the rise of really main-stream object-oriented programming languages. The nice thing about XP was that you could show a nice graph where you planned, managed, designed, coded, and tested your software. The rules of Extreme Programming included things like “Code the unit test first” - and “A stand up meeting starts each day.” Extreme Programming is one of these methodologies. Scrum is probably the one most commonly used today. But the rest, as well as the Crystal family of methodologies, are now classified as Agile software development methodologies. So it’s like a parent. Is agile really just a classification then? No. So where did agile come from? By 2001, Kent Beck, who developed Extreme Programming met with Ward Cunningham (who built WikiWikiWeb, the first wiki), Dave Thomas, a programmer who has since written 11 books, Jeff Sutherland and Ken Schwaber, who designed Scrum. Jim Highsmith, who developed that Adaptive Software Development methodology, and many others were at the time involved in trying to align an organizational methodology that allowed software developers to stop acting like people that built bridges or large buildings. Most had day jobs but they were like-minded and decided to meet at a quaint resort in Snowbird, Utah. They might have all wanted to use the methodologies that each of them had developed. But if they had all been jerks then they might not have had a shift in how software would be written for the next 20+ years. They decided to start with something simple, a statement of values; instead of Instead of bickering and being dug into specific details, they were all able to agree that software development should not be managed in the same fashion as engineering projects are run. So they gave us the Manifesto for Agile Software Development… The Manifesto reads: We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value: * Individuals and interactions over processes and tools * Working software over comprehensive documentation * Customer collaboration over contract negotiation * Responding to change over following a plan That is, while there is value in the items on the right, we value the items on the left more. But additionally, the principles dig into and expand upon some of that adjacently. The principles behind the Agile Manifesto: Our highest priority is to satisfy the customer through early and continuous delivery of valuable software. Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage. Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale. Business people and developers must work together daily throughout the project. Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done. The most efficient and effective method of conveying information to and within a development team is face-to-face conversation. Working software is the primary measure of progress. Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely. Continuous attention to technical excellence and good design enhances agility. Simplicity--the art of maximizing the amount of work not done--is essential. The best architectures, requirements, and designs emerge from self-organizing teams. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly. Many of the words here are easily weaponized. For example, “satisfy the customer.” Who’s the customer? The product manager? The end user? The person in an enterprise who actually buys the software? The person in that IT department that made the decision to buy the software? In the scrum methodology, the customer is not known. The product owner is their representative. But the principles should need to identify that, just use the word so each methodology makes sure to cover it. Now take “continuous delivery.” People frequently just lump CI in there with CD. I’ve heard continuous design, continuous improvement, continuous deployment, continuous podcasting. Wait, I made the last one up. We could spend hours going through each of these and identifying where they aren’t specific enough. Or, again, we could revel in their lack of specificity by pointing us into the direction of a methodology where these words get much more specific meanings. Ironically, I know accounting teams at very large companies that have scrum masters, engineering teams for big projects with a project manager and a scrum master, and even a team of judges that use agile methodologies. There are now scrum masters embedded in most software teams of note. But once you see Agile on the cover of The Harvard Business Review, you hate to do this given all the classes in agile/XP/scrum - but you have to start wondering what’s next? For 20 years, we’ve been saying “stop treating us like engineers” or “that’s waterfall.” Every methodology seems to grow. Right after I finished my PMP I was on a project with someone else that had just finished theirs. I think they tried to implement the entire Project management Body of Knowledge. If you try to have every ceremony from Scrum, you’re not likely to even have half a day left over to write any code. But you also don’t want to be like the person on the elevator, weaponizing only small parts of a larger body of work, just to get your way. And more importantly, to admit that none of us have all the right answers and be ready to, as they say in Extreme Programming: Fix XP when it breaks - which is similar to Boyd’s Destruction and Creation, or the sustenance and destruction in Lean Six-Sigma. Many of us forget that last part: be willing to walk away from the dogma and start over. Thomas Jefferson called for a revolution every 20 years. We have two years to come up with a replacement! And until you replace me, thank you so very much for tuning into another episode of the History of Computing Podcast. We’re lucky to have you. Have a great day!


Bill's Problem with Piracy

     11/25/2019

In this mini-episode we look at a strange event in Microsoft's early history and their first case of piracy. Along the way you will learn about the best advetrizing campaign in history: the MITS MOBILE Computer Caravan!

Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing

Important dates in this episode:

1976: 'Open Letter to Hobbyists' Written by Bill Gates

http://tee.pub/lic/4jnwv7m_ZPw


Journey to Altair

     9/8/2019

Today we are going to be traveling back to the late 1970s to take a look at the early days of the home computer. And specifically how Microsoft found a foothold at just the right time and place. And for Bill Gates and Paul Allen that would come in the form of BASIC.

Along the way we will cover the Altair 8800, vaporware, and how Bill Gates violated Harvard student conduct.

Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing

Important dates in this episode:

1974: Altari 8800 Released
1975: Microsoft BASIC Released


WordStar

     1/8/2021

We’ve covered Xerox PARC a few times - and one aspect that’s come up has been the development of the Bravo word processor from Butler Lampson, Charles Simonyi, and team. Simonyi went on to work at Microsoft and spearheaded the development of Microsoft Word. But Bravo was the first WYSIWYG tool for creating documents, which we now refer to as a word processor. That was 1974. 

Something else we’ve covered happened in 1974, the release of the Altair 8800. One aspect of the Altair we didn’t cover is that Michael Shrayer was a tinkerer who bought an Alatir and wrote a program that allowed him to write manuals. This became the Electric Pencil. It was text based though and not a WYSIWYG like Bravo was. It ran in 8k of memory and would be ported to Intel 8080, Zylog Z-80, and other processors over the years leading into the 80s. But let’s step back to the 70s for a bit. Because bell bottoms. 

The Altair inspired a clone called the IMSAI 8080 in 1975. The direct of marketing, Seymour Rubenstein started tinkering with the idea of a word processor. He left IMSAI and by 1978, put together $8,500 and started a company called MicroPro International. He convinced Rob Barnaby, the head programmer at IMSAI, to join him.

They did market research into the tools being used by IBM and Xerox. They made a list of what was needed and got to work. The word processor grew. They released their word processor, which they called WordStar, for CP/M running on the Intel 8080. By then it was 1979 and CP/M was a couple years old but already a pretty dominant operating system for microcomputers. Software was a bit more expensive at the time and WordStar sold for $495.

At the time, you had to port your software to each OS running on each hardware build. And the code was in assembly so not the easiest thing in the world. This meant they wanted to keep the feature set slim so WordStar could run on as many platforms as possible. They ran on the Osborne 1 portable and with CP/M support they became the standard. They could wrap words automatically to the next line.  Imagine that. 

They ported the software to other platforms. It was clear there was a new OS that they needed to run on. So they brought in Jim Fox, who ported WordStar to run on DOS in 1981. They were on top of the world. Sure, there was Apple Write, Word, WordPerfect, and Samna, but WordStar was it.

Arthur C Clarke met Rubenstein and Barnaby and said they "made me a born-again writer, having announced my retirement in 1978, I now have six books in the works, all through WordStar." He would actually write dozens more works. 

They released the third version in 1982 and quickly grew into the most popular, dominant word processor on the market. The code base was getting a little stale and so they brought in Peter Mierau to overhaul it for WordStar 4. The refactor didn’t come at the best of times. In software, you’re the market leader until… You thought I was going to say Microsoft moved into town? Nope, although Word would eventually dominate word processing. But there was one more step before computing got there. 

Next, along with the release of the IBM PC, WordPerfect took the market by storm. They had more features and while WordStar was popular, it was the most pirated piece of software at the time. This meant less money to build features. Like using the MS-DOS keyboard to provide more productivity tools. This isn’t to say they weren’t making money. They’d grown to $72M in revenue by 1984. When they filed for their initial public offering, or IPO, they had a huge share of the word processing market and accounted for one out of every ten dollars spent on software. 

WordStar 5 came in 1989 and as we moved into the 90s, it was clear that WordStar 2000 had gone nowhere so WordStar 6 shipped in 1990 and 7 in 1991. The buying tornado had slowed and while revenues were great, copy-protecting disks were slowing the spread of the software. 

Rubinstein is commonly credited with creating the first end-user software licensing agreement, common with nearly every piece of proprietary software today. Everyone was pirating back then so if you couldn’t use WordStar, move on to something you could steal. You know, like WordPerfect. MultiMate, AmiPro, Word, and so many other tools. Sales were falling. New features weren’t shipping. 

One pretty big one was support for Windows. By the time Windows support shipped, Microsoft had released Word, which had a solid two years to become the new de facto standard. SoftKey would acquire the company in 1994, and go on to acquire a number of other companies until 2002 when they were acquired. But by then WordStar was so far forgotten that no one was sure who actually owned the WordStar brand. 

I can still remember using WordStar. And I remember doing work when I was a consultant for a couple of authors to help them recover documents, which were pure ASCII files or computers that had files in WordStar originally but moved to the WSD extension later. And I can remember actually restoring a BAK file while working at the computer labs at the University of Georgia, common in the DOS days. It was a joy to use until I realized there was something better.

Rubinstein went on to buy another piece of software, a spreadsheet. He worked with another team, got a little help from Barnaby and and Fox and eventually called it Surpass, which was acquired by Borland, who would rename it to Quattro Pro. That spreadsheet borrowed the concept of multiple sheets in tabs from Boeing Calc, now a standard metaphor. Amidst lawsuits with Lotus on whether you could patent how software functions, or the UX of software, Borland sold Lotus to Novell during a time when Novell was building a suite of products to compete with Microsoft.

We can thank WordStar for so much. Inspiring content creators and creative new features for word processing. But we also have to remember that early successes are always going to inspire additional competition. Any company that grows large enough to file an initial public offering is going to face barbarian software vendors at their gates. When those vendors have no technical debt, they can out-deliver features. But as many a software company has learned, expanding to additional products by becoming a portfolio company is one buffer for this. As is excellent execution. 

The market was WordStar’s to lose. And there’s a chance that it was lost the second Microsoft pulled in Charles Simonyi, one of the original visionaries behind Bravo from Xerox PARC. But when you have 10% of all PC software sales it seems like maybe you got outmaneuvered in the market. But ultimately the industry was so small and so rapidly changing in the early 1980s that it was ripe for disruption on an almost annual basis. That is, until Microsoft slowly took the operating system and productivity suite markets and .doc, .xls, and .ppt files became the format all other programs needed to support. 

And we can thank Rubinstein and team for pioneering what we now call the software industry. He started on an IBM 1620 and ended his career with WebSleuth, helping to usher in the search engine era. Many of the practices he put in place to promote WordStar are now common in the industry. These days I talk to a dozen serial entrepreneurs a week. They could all wish to some day be as influential as he. 


(OldComputerPods) ©Sean Haas, 2020