3

Many early operating systems were single-tasking. However, sometimes small programs were developed that could share the system and user interface with a main program. Examples include Borland Sidekick and Macintosh desk accessories. They were able to provide users with tools such as calculators, alarm clocks, and calendars. What was the first operating system to support such "desk accessories"?

To clarify the question, we will use Wikipedia's definition of desk accessory:

A desk accessory (DA) in computing is a small transient or auxiliary application that can be run concurrently in a desktop environment with any other application on the system.

Multitasking operating systems do not count. One program loading another program (e.g. shells) does not count. Overlays do not count.

6
  • 8
    I'm not sure about desk accessories but the IBM 1620 had a built-in desk, does that count?
    – davidbak
    Jun 27 at 5:06
  • 1
    Macintosh had them, and the only GUI system before it was the one from PARC. So, it’s either Mac or Alto.
    – RonJohn
    Jun 27 at 6:03
  • 8
    So basically "which OS wasn't designed to do multitasking, but you could hack it to do some limited amount of multitasking, and you are not allowed to use OS features"? Strange question. And I'd argue that IBM PC TSR did use OS features, so ruling out overlays but not ruling out TSR is a bit arbitrary... Does something like using the & feature on the Apple II count?
    – dirkt
    Jun 27 at 6:35
  • 3
    With a bit of machine code hacking you could display the currently executing line number top left of the screen on a Spectrum. Does that count? It's a small auxiliary application running concurrently with the main program!
    – Martin
    Jun 27 at 7:02
  • My first impression from the title was that it was asking about branded coffee cups or other swag for engineer’s desks. Hmmm…
    – Jon Custer
    Jun 28 at 12:37

1 Answer 1

4

TL;DR:

I'll suggest four 'winners' depending on category:

  1. Mainframe overlay frameworks of ca. 1970
  2. RCA's TSOS (respectively Siemens BS2000), ca. 1970 onward, offering the ability to break any single tasking user program into command line (*1) and running build-in tools like debugger or calculator.
  3. Xerox Alto/Star (1973 onward), as handling multiple windows/accessories wasn't made via a dedicated multitasking OS, but within the application environment. Kinda related to overlays within a framework in the early days (see #1).
  4. MP/M by DR, published in 1979 for 8080 machines. While conceived as a system to share a computer between several users, it became most popular with 'power' users, due the ability to detach ones terminal from a one program and attach it to another one. Or in today's words: switching between programs.

The Fine Print:

Well, questions about 'first' usually tap into a blurry picture, as the prerequisite set up by the question, seemingly clear today weren't canonized in 'the good old days'.

For example, there is no clear separation between OS, programming language and application in the Xerox Alto/LispMachine/Star series. Thus it'S hard to say if working on a letter and a spreadsheet at the same time is multitasking because of the OS, or simply two opened documents because of the application.

Adding to blur are contradicting assumptions like "... share the system and user interface with a main program. Examples include Borland Sidekick and Macintosh desk accessories". While Mac Accessories really share the desktop at the same level as the main application, Sidekick doesn't. It halts the main application, takes over the whole machine, saves the screen and acts as new main application. In the end, SideKick is a preloaded overlay which shouldn't count according to the question. isn't it?

Similar the exclusion of overlays is harsch exactly on early systems, where such techniques were the only way to archive enhanced functionality at all. Many early (real mode, single tasking) interactive mainframe systems were build as frameworks where each and every function was realized as overlay, called in (if not already present) by whatever function a user requests. After all, in 1970, when this became a thing, average mainframes had memory sizes of 32..128 KiB. Not really something to hold multiple programs all time in memory. Virtual memory, which would automate this, was, at that time, a luxury for upper end devices. Real mode systems build on that scheme existed way into the 1980s (*2). The only difference by then was that machines offered several megabytes, allowing the overlay cache to hold essentially all code at once :)

Likewise the definition of multitasking is a wide one. But is it still multitasking in the sense of the question if an OS offers parallel tasks, but a User can only access one at a time (think MP/M)?

Or more so, what about Systems where user/terminal/task assignment is fixed, but one can break a running (user) program and operate arbitrary system commands/tools? Think of such a system as being a monitor handling resources, and memory with a loaded user program being just one of them.

Last, but not least, asking explicit for 'Desk'accessories excludes everything not being a desktop computer (do tower and Laptop still count?) and/or using a desk metaphor, which would as well put SideKick out of scope, wouldn't it?

Conclusion: Like so often a question using terminology/environment from one point in time may not make much sense before that point.


*1 - No, that's not opening a (sub-)shell but falling back into the primary shell (there is only one) and using arbitrary OS commands while the user program is still loaded. Calling CALC that way is quite similar to open SideKicks calculator on top of any application.

*2 - Wouldn't be surprised if some still do.

4
  • Access to the SSCP session on a 3270 doesn't count? ;-) Jun 27 at 11:28
  • @another-dave Well, not really, as it's a network feature. Then again, good example for the uncanny valley of using terms before they had meaning in a world with more than one solution to a problem - or where the problem simply never have arisen :))
    – Raffzahn
    Jun 27 at 11:54
  • ISPF's (IBM TSO) panels ? Jun 28 at 18:29
  • @StefanSkoglund Oh yeah. (I)SPF would be the most well known of such frameworks. Although itself being late to the game (1975?) it features eventually the best integration within the OS while being quite usable/open for third party applications (panels).
    – Raffzahn
    Jun 28 at 22:16

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.