|
The
Mac at 20
The DigiBarn Computer Museum Celebrates From Chuck Colby (January 8, 2004): The day the Mac was introduced 20 years ago at the Hyatt Regency Hotel in San Francisco, in the back of the room (on two fold up card tables) there were two other companies showing Mac related things. At this, the first Mac World, one company was a small software company named Microsoft. The other company was an even smaller company called Colby Systems with a product called MacColby, which was the first portable Mac. It was built using the case of our MS-DOS portable, by replacing the IBM PC motherboard with a Mac motherboard (which I had gotten it from Steve Wozniak in December 1983 when I was over at his house installing his Satellite TV system that I had designed for him), adding two Mac floppy drives and changing the keyboard to a Mac keyboard. The display was the hardest to get going because the Mac used a horizontal scanning frequency that was non-standard and twice the frequency of a standard video monitor. After Jobs did the big introduction, he introduced John Sculley the new Apple President, who gave his presentation. When Sculley was done on stage, he came to the back of the room to see what the excitement was around the MacColby. Sculley ordered 2 MacColbys on the spot (one for himself and one for his son who was attending Stanford). He arranged for the two Mac motherboards to be sent to Colby, and we delivered the two Mac Colbys to him a week later. However, he never paid for them, so here we are 20 years later and with compounded interest, I figure Apple owes me $20,000 or so, which I will be glad to take in new Mac hardware and software!
Please contribute your entry today! Also see DigiBarn Curator Bruce Damer's Commentary on 20 years of the Mac! From
David T Craig
(January 8, 2004): OVERVIEW This commentary contains my recollections about developing 3rd party software for the Apple Macintosh computer during the years 1984 to 1986. This paper was written as my contribution to the Macintosh's 20th anniversary celebrations in February 2004. During this time I worked for a small company in Wichita Kansas called PPP Inc. (PPP = Programs for Professional People) which developed a new Macintosh application for the stock market named The Investor. This application was written in Lisa Pascal and contained around 50,000 lines. I and another individual designed the program and I implemented it. The original Macintosh (called the "Macintosh 128" since it had 128K bytes of memory) provided a fascinating development and application platform which I enjoyed immensely. The Macintosh's rich ROM based software toolbox along with the machine's small footprint and superbly clear screen display made the Macintosh a wonderful application platform. SOFTWARE DEVELOPMENT WITH THE LISA WORKSHOP ENVIRONMENT Macintosh development in the early days (circa 1983-1985) was done using the Apple Lisa computer and its Lisa Workshop development environment. I originally used a Lisa 2/5 model which contained 1M byte of RAM, an internal 400K 3.5" floppy drive, and an external 5M byte ProFile hard drive. I later used a Lisa 2/10 model which had an additional 10M byte internal Widget hard drive which gave me a total of 15M bytes of hard drive storage. The Lisa Workshop contained a command line interface which accessed a wonderful mouse based editor, the Lisa Pascal compiler, the object file Linker, the RMaker resource compiler utility program, and the MacCom Lisa-to-Macintosh utility communications program. The Lisa Pascal language was very powerful and compiled Pascal source files to Motorola 68000 object code files. I never found a need to use the Workshop's 68000 assembler since everything I needed for my application could be written in higher level Lisa Pascal language. Macintosh application resource information was created as text files which were then compiled to a binary format using the RMaker resource compiler. Transferring a Macintosh object program from the Lisa to the Macintosh required the Lisa utility program MacCom which copied Lisa files to a Macintosh formatted disk in the Lisa's 400K internal disk drive. MacCom combined seperate Lisa data fork and resource fork files which were stored on the Lisa's hard drive and stored them as single documents on the Macintosh floppy. Macintosh programming was based on a collection of programming libraries called Pascal Units in Pascal parlance. These resided on the Lisa and implemented the Macintosh application programming interface (called the Toolbox and Operating System by Apple). These libraries came on Lisa formatted disks called the Lisa Macintosh Supplement. I recall receiving around 3 or 4 supplements each with around a half dozen disks with these libraries. These disks also contained Macintosh utility and sample applications such as the Uriah Heap desk accessory by Andy Hertzfeld (called desk ornaments in the early days), the Edit text editor, and the File application by Cary Clark which showed detailed examples of Macintosh programming. Macintosh development using a Lisa 1 model was also possible though I never worked with the Lisa 1. For this computer, which did not contain an internal Macintosh compatible 400K byte floppy drive, you transmitted you Macintosh program from the Lisa to the Macintosh via the Lisa's serial using a special Lisa utility. A special Macintosh utility received the transmitted file. Macintosh development was also done using the Lisa Monitor development environment, but I never used this. The Monitor was the Workshop's predecessor and was also command line based though its command structure was more UCSD p-system based then the later Workshop command structure. Around later 1984 or 1985 Apple provided the Macintosh Development System (MDS) which ran on the Macintosh 512K model I recall. This allowed you to develop 68000 assembly language programs on the Macintosh. I never used it since I didn't write in assembly language (too tedious) and I had a Lisa with the Workshop and its wonderful Lisa Pascal language. SOFTWARE DEVELOPMENT WITH THE MACINTOSH MPW ENVIRONMENT I used a beta version of the MPW (Macintosh Programmer's Workshop) programming environment around late 1985 early 1986 for Macintosh development. This was Apple's successor to the Lisa Workshop which was being discontinued since the Lisa hardware had been discontinued in 1985. MPW ran on the then new Macintosh Plus computer which contained 1M byte of RAM and an internal 800K byte 3.5" floppy drive. I recall using an external floppy drive for my MPW development of The Investor application which worked fine, but compiles were much slower than the Lisa Workshop compiles. MPW was a very good development environment which I still use today (it now is up to version 3.4 or 3.5 I believe). MACINTOSH TOOLBOX/OPERATING SYSTEM AND INSIDE MACINTOSH Macintosh programming was based on the Macintosh application programming interface (API) called the Macintosh Toolbox and Operating System routines. There were around 500 of these routines in the original Macintosh. As a comparison, I just counted the number of routines in the MPW 3.2 Pascal interfaces for the Mac API and there were around 2,300 (almost 5 times as many). The Macintosh API introduced (at least to me) new programming topics such as event based programming, resources, and internationalization of text, numbers, and dates. One area which the Macintosh API attempted to teach developers was that the Macintosh was really a software system and not a hardware system. Prior Apple systems (the Lisa excluded) were more hardware oriented. Instead of writing data to a memory location for screen display, you instead used the QuickDraw graphics library. Apple wanted Macintosh developers to use the Macintosh API extensively since it already provided most of the core features of applications, ran fast, and was well documented. API usage also tended to promote a standardized user interface which really did not exist for Apple's earlier Apple II and III computers. The Macintosh Print Manager was a joy to use. It provided a device independent architecture for printing really nice looking text and graphics. The old days of sending printer specific control codes to a printer and hoping for the best were at an end. The Macintosh Memory Manager and its use of handles was an eye opener. This handle architecture provided a simple way to maximize the use of the Macintosh's limited memory size (the Macintosh team has to thank Tom Malloy of the LisaWrite word processor team for this). The Macintosh API was documented in a wonderful collection of notes called collectively "Inside Macintosh". Originally distributed on a chapter basis these eventually were collected in several volumes. Each chapter documented a specific Macintosh API "manager" such as the Menu Manager. Volumes 1 to 3 containing the original Macintosh API information. Volume 4 documented from 1986 the Macintosh Plus and the API changes made for this machine (such as the new SCSI disk manager). Volume 5 from 1988 documented the Macintosh II and its extensive API additions (such as Color QuickDraw). The early Inside Macintosh chapters also contained API features which were later removed by Apple. For example, the Core Edit manager supported styled text and was a superset of the simpler TextEdit manager. Core Edit was documented in a 1982 or 1983 Inside Macintosh chapter, but was removed from the 1984 Inside Macintosh. Inside Macintosh was from my perspective very well written and provided in a very readable fashion a structure which made understanding the Macintosh API much easier. Inside Macintosh's structure was designed from the beginning and all the chapters had the same appearance and readability even though they were written by many different people. Caroline Rose was the key person behind the original Inside Macintosh chapters. She was ably assisted by around a half dozen writers. Technical notes were also provided as part of the early Inside Macintosh releases. I recall a note from Bill Atkinson describing the internal format of MacPaint documents (he was MacPaint's original author and the programmer for QuickDraw graphics library for the Lisa and Macintosh). Actual Macintosh system programming sources were also provided as examples. These includes all the Macintosh "definition procedures" which implemented features such as window and menu appearances (Andy Hertzfeld wrote these). The sources for the more interesting ROM managers such as the Window or Menu Managers was alas not provided (maybe today, how about it Steve Jobs?). EARLY MACINTOSH DEVELOPMENT DISAPPOINTMENTS Though the original Macintosh provided a revolutionary user interface and application programming interface (API), there were some disappointments from my perspective. Programming the Macintosh took a long time. Instead of having an application interface consisting of a simple command line interface whose output was a bunch of text lines in a fixed size font, you instead had to manage menus, multiple windows, resources, and events. Apple could have developed higher level API routines which would have lessened some of the 3rd party development work. For example, in addition to the TextEdit manager, the Macintosh ROM would have contained a TextEdit tool which would have displayed and handled multiple text windows. Unfortunately, this would have required additional programming resources on Apple's part and possiblly a larger ROM (say 128K instead of 64K bytes). This type of problem was later solved to some degree by Apple's MacApp object oriented environment but that was many years down the road from 1984. Sophisticated Macintosh
applications required more resources than the Macintosh 128 provided.
The original Macintosh's 128K bytes of memory and 400K byte disk drive
were on the small size when it came to sophisticated applications (I
recall reading that even in Apple there was lots of discussion about
this). The original Macintosh was really around a 90K byte memory machine
since the screen took 22K bytes of memory and a bit of memory was devoted
to system code such a ROM patches and file system buffers. I recall
my Investor application was around 200K bytes in size and though it
ran on the original Macintosh it was slow due to constant application
code segment swapping. The Macintosh 512 ran our program well. It is
a shame that the original Macintosh didn't have a bigger memory (I recall
reading about a 256K Macintosh) and more disk space (the Macintosh originally
used a Lisa 860K byte 5.25" Twiggy floppy drive which would have
been wonderful, but in late 1983 Apple changed From a programming perspective, the Lisa Pascal language was good, but it could have been better. For example, routine and variable names were significant to only 8 characters. This ment that the names such as FlushBuffersNow and FlushBuffersSoon were seen as the same by the Pascal compiler. Apple should have changed the compiler to support at least 16 character name significance, or even better 32 characters. 8 character significance was a real pain for me and reminded me of Apple's Apple II and III Pascal compilers. Internal Macintosh API data structures should not have been published in Inside Macintosh. Apple knew these were going to change so should not have tempted developers into using this information. This would have been difficult to do given the Lisa Pascal compiler's scoping limitations, but Apple could have changed the compiler to support public and private information better (a Modula-2-type architecture could have been useful here from what I know). The Macintosh API use of global variables was not good (these were also known as "low memory variables"). These promoted the Macintosh as a single process system which later was difficult for Apple to upgrade when it wanted to run real processes on the Macintosh. These global variables also made the Macintosh API non-reentrant which caused problems for interrupt-based tasks. MACCOLLEGE Around the end of 1984 I attended a wonderful Macintosh programming seminar called MacCollege. Held at Apple's Cupertino headquarters it provided a facility with direct access to Lisa computers for development and Apple's original Macintosh technical support team. Support persons such as Scott Knaster, Cary Clark, and Russ Daniels presented Macintosh information, answered programming questions, and helped resolve bugs in your application. I recall at the end of MacCollege signing a large piece of cardboard paper which had around a hundred names of all the MacCollect graduates (I wonder where this is today?). REFERENCES Here are a list of the key materials that I used during the early Macintosh development days. I still have all these materials including The Investor source code listing and internal architecture manual.
|
||||||||
Please
send site comments to our Webmaster.
Please see our notices about the content of this site and its usage.
(cc) 1998- Digibarn Computer Museum,
some rights reserved under this
Creative Commons license.
