History of the Windows API

 

Books are available which chart the success of Windows. From a programmers point of view the approximate (and innacurately dated) history goes something like the following. Although the intricacies of the early versions of Windows are not entirely relevant, the fact that Windows has evolved from a shared memory OS with some input from the OS/2 program is still visible in the current API. This explains why a lot of things don't seem to make a lot of sense.

1983 (?)Windows is announced
(i.e. work on it begins). Based on Xerox Parc work and predating the Mac -although the Lisa may have had some influence.
1984 Work begins on Word for Windows 1.0
November 1985: Windows 1.0 launched
Tiled windows only (for legal and ease of clipping reasons). Real mode (sub 1MB) memory model. Programs co-operatively multitask in the same memory space -GetMessage() enabling the windowing system to switch apps. GlobalAlloc() handles refer to entries in the global handle table -the location of the allocated buffers can change whenever the app yields. Dialog boxes and the dialog processing loop have to be done from scratch. Low level operations are done via DOS interrupts.
Microsoft C and Assembler are the development tools -these are run in DOS and then you have to start up Windows to actually run the app. Debugging requires a second monitor and graphics card.
April 1987 Windows 2.0
Windows can now overlap. The SDK becomes commercially available as an add on to MS C 5.0: all the documentation fits into a single slender loose leaf folder. Dialog boxes are now easier because of built in support for dialog box creation and processing.
The killer app is Excel -in fact Excel includes a cut down copy of Windows, as the market penetration is still tiny.
MS OS/2 is announced at the same time as the Win2.0 launch
1988 "Programming Windows" published.
By Charles Petzold. Programmers can now write programs which work. Microsoft support help you with programming problems without asking for a credit card.
1988 OS/2 1.1 with Presentation Manager
This is _similar_ to Windows, but runs in protected mode only (i.e. needs a '286). The origin for drawing is the bottom left corner. The Device Independent Bitmap (BMP/DIB) format is defined.
1988? Windows/286 + /386
Windows goes up to version 2.04 then splits into Windows/286 and Windows/386, the latter supporting multiple DOS boxes. Apps can address memory over 1MB through the LIM/EMS BIOS extensions. When each app runs its own high memory buffers are switched to -so shared memory must be allocated below 640KB with the GMEM_LOWER flag. Programmer productivity is boosted because we can now run the DOS compiler from within windows.
November 1989: Winword 1.0 finally ships: four years after the original scheduled date.
May 1990 : Windows 3.0 ships
This is the first version of Windows which the world really notices. It operates in 3 modes -real (8086 mode as for Windows 2.x), protected ('286) and enhanced ('386, with multiple DOS boxes and virtual memory). Ignoring real mode, the -16 bit- Windows API has now fundamentally altered to a segmented memory model. The handle returned from GlobalAlloc() now returns something close to a 286 segment descriptor. With the CPU doing the mapping from segment:offset to a physical location, apps can have their memory moved about without having to worry.
Many existing apps crash with "Unrecoverable Application Error" dilaogs because they read or write memory they should not have, but which previous versions permitted. User and GDI handles still index data structures within the data segments of the relevant DLLs; the OS functions which use these handles trust the calling programs -sacrificing robustness for performance.
The OS2 bitmap format is adopted for image storage, which is why bitmaps are still stored "upside down" compared to the rest of Windows to this day. The SDK documentation now comprises three bound paperbacks.
Late 1990 (?) Microsoft C 6.0 ships
Still a DOS box application, it now contains a basic IDE in which F1 will bring up keyword and compiler error help. This seems a fundamental improvement at the time. This IDE, the "Programmer's Work Bench" suffers from the need for users to learn its macro API before the TAB key actually inserts a tab, rather than acting as a cursor. "Programmer's Whipping Bench" becomes it's semi-affectionate name
Late 1990: MS and IBM persue separate Operating System strategies.
IBM want to go with OS/2, and use OS ownership as a way of differentiating their PCs from the growing clone market. MS want to maximise revene through selling their OS to everyone, and provide a better migration path from DOS. They agree to follow their own paths.
Late 1990/Early 1991 Windows for Pens and Multimedia Windows
These are special editions of Windows 3.0. Because the MM extensions are not part of the standard windows build, an extra DLL -MMSYSTEM.DLL- is added. This why you still need to link to MMSYSTEM.LIB to use functions like PlaySound()
Spring 1991: Borland C++ ships
The first Borland compiler to produce Windows code, this DOS based IDE becomes the first mainstream C++ compiler for the PC. Not only is it a blindingly fast compiler, the debugger works without needing a second monitor. Borland C++ 2.0 follows, which handles more advanced C++. As the first real competitor to the Microsoft products, it and its successors become the spur to the introduction of the Visual C++ product family.
Summer 1991 (?) Visual Basic 1.0
One of the first RAD tools for Windows: primitive but good for prototyping and some other applications. The VBX architecture for extension libraries becomes the most successful software component model to date.
Late 1991: Windows 3.1
Multimedia extensions become part of the standard build, OLE 1.0 is included (very hard for programs to support) and processor exception #13 now brings up a "General Protection Fault" dialog box. Toolhelp.DLL enables better debuggers to be written -this has follow on benefits. User and GDI handles still refer to data structures in the DLL's private data areas, but now the functions which take such handles as parameters actually verify the handles' validity. Common dialog boxes for file open/save, color selection and printing make common tasks significantly easier.
Minor variations to existing functions appear (such as MoveTo() being extended by MoveToEx()), and the "windowsx.h" header file provides stricter type checking and message cracking macros. These are all to simplify the transition to Win32 when the time comes.
Later 1991: OWL 1.0
This is an add on for Borland C++: a class library which relies on non-standard extensions to the C++ language to map messages to class member, and provides a smalltalk like wrapper around some common Windows elements (like windows themselves, but not device contexts or GDI objects)
1991? Quick C for Windows
This is the forerunner of all of the Visual products: A Windows based IDE for C applications. The output was limited to console like apps, but the origins of current products lie in this tool.
Early 1992: Borland C++ 3.0
The first of the Windows based C++ IDEs. OWL 1.0 is included. It's pretty flaky, but version 3.1 is fairly stable.And fast.
Mid 1992 (?): Microsoft C/C++ 7.0 ships
Still DOS based, and using the now aging Programmers Work Bench IDE, this, the first C++ compiler from MS comes with the first version of the MFC class libraries. Like OWL 1.0 all coding is by hand, but this class library wraps GDI objects too.
Mid 1992 (?) OLE2.0 betas/launches
This is the first version of OLE to use COM as its foundation.
Late 1992: Preliminary Win32 API published as NT beta released.
The first copies of NT appear, along with an API which is close enough to the classic Windows API that migration is relatively easy -especially if you used the STRICT macros. Win32s is also announced: it turns out Win31 has been designed with the hooks in to enable the OS to recognise 32 bit applications and offload their execution to appropriate VxDs.
Win32 on NT offers pre-emptive multitasking, separate memory spaces for individual processes and many other relatively advanced OS features. Memory handles now point to addresses within each process's private memroy, with special tricks done by the OS to support situations (DDE & WM_SETTEXT) where apps assume that they are shared.
April 1993: Visual C++ 1.0 launches
The first C++ compiler to simplify code development through wizards for application creation and dialog box interaction. Although disappointingly not as visual as Visual Basic, it is still a usability advance over anything else. Behind the scenes the old command line compiler is still being used, so it is a bit of a clunky development system. A nice feature: VBXs are supported -this requires a lot of work to make C++ apps act like the VB environment.

This product is especially memorable as the last C/C++ developer tool Microsoft ever shipped with complete printed documentation.

Summer 1993: NT 3.1 Launches
Only version 1.0 of OLE is supported, and the OS is slow and heavy -12+ MB of memory costs a lot of money at the time. It finds some takeup as a server, partly due to the unlimited client license. As well as x86 CPUs, NT becomes availble for MIPS and Alpha CPUs. Visual C++ for Windows NT soon follows: this is a 32 bit build of the VC++1.0 IDE .
November 1993: Visual C++ 1.5 launches.
This adds OLE2 support to the class libraries, and turns out to be the last of the 16 bit compilers from Microsoft.
December 1993: Chicago M5 Build
Free to everyone at the Anaheim Windows Professional Developers Conference. This is the first beta of what ultimately becomes Windows 95, and although it already pre-emptively executes Win32 apps, the UI evolves significantly before the final release.
Early 1994: Borland C++4.x ships
Although pretty unreliable at its initial launch, this is an ambitious tool which can generate 16 or 32 bit code, and contain "experts" to compete with the Visual C++ Wizards. OWL 2.x represents a fundamental revision of the C++ class libraries, and OWL 1.0 apps need major rewrites to be able to recompile, let alone work.
Summer 1994: NT3.5 launches
This version is tuned for size and performance, and is slightly more popular. It contains a 32 bit winsock stack which marks the first major adoption of TCP/IP -the base protocols of the Internet- by Microsoft.
Late 1994: Visual C++ 2.0 ships
A 32 bit only IDE to generate 32 bit only code, this is part of a deliberate strategy to force all developers to move to the Win32 API. Win16 coding requires the VCC1.5 compiler which is included in the package. Shipping what was effectively a 32 bit compiler nine months before a mainstream 32 bit Windows platform launched was a daring move, which could have been exploited by Borland. As the now named Windows 95 goes through its beta releases, versions of the compiler are released to keep developers up to date.
Early 1995: the Ole Control Developer Kit ships
This is an add on to VCC2.x, which can be used to migrate VBXs to the 16 and 32 bit world of OCXs.
August 1995: Windows 95 ships
The most successful software launch to date, Win32 now becomes a mainstream API, instead of a niche for high end server applications. The Win32 API now contains extensions for the new UI controls and COM interfaces for shell interaction. Other parts of Win32 are not implemented.
September 1995: Windows NT3.51
Windows NT3.51 is released to support some of the new common controls, and becomes the first version of NT for the Power PC. Still regarded by many as the most solid version of NT for servers -many consumer oriented features in future versions -DirectX, Explorer shell, Web browser integration- are viewed with despair server side.
Late 1995: DirectX 1.0 released
The DirectX APIs -evolving at a faster rate than the base OS- are designed to make Windows the ideal platform for games. Originally concentrating on provide hardware independent access to frame buffer memory and sound cards, these APIs are now becoming the foundation for 3D and broadcast TV related applications.
December 1995: ActiveX announced
The Microsoft Internet Strategy announcment previewed the OCX download feature of IE3, and provided a roadmap of how Internet support would become an integral feature of the operating system.
Summer 1996: NT4.0
This extended NT with the Windows 95 shell, and many of the DirectX APIs. At a lower level Winsock 2 and Distributed COM can both be used for advanced networking applications. The API also gained Timer objects, which may have a critical role in low power and OnNow aware applications. MIPS and PowerPC support is dropped: Alpha becomes the only non-x86 CPU to support Win32 .
Summer 1996: IE3.0 ships
This optional extension to the Window's platforms extends the desktops with new common controls, a web browser OCX and Wininet.DLL
Late 1996: Windows CE 1.0 announced
The availability of Win32 on embedded processors palmtop computers -and ultimately in embedded products- was announced at Comdex in 1996.
September 1997: IE4.0 Ships
Another extension to Win95 and NT4 significantly extends the shell, adds more common controls, Distributed COM (to '95) and an OLE Automation interface to many shell services.
June 1998: Win98 Ships
IE4 is built in, serious kernel reworkings to support new interconnection technologies and better power management. [details]
August 1998: NT5 Beta 2
The first vaguely stable beta of the Windows OS of the Future
September 1998: Visual Studio 6.0
Better C++ IDE/compiler, better web development, and a non standard variant of Java.
March 1999: IE5 Ships
Some changes to Wininet.dll, among other things, but not a seminal event. IE4.1 would be a more accurate name.
April 1999: NT5 Beta 3
COM+ goes in, lots of other things get more stable
May 1999: Win98 SE
Very little change over Win98.0, but more consistent behaviour with NT5 than before. [details]
Feb 2000: Windows 2000
The most significant windows release since Win95. Windows 2000 finally grows up. [details]
 

[contact ] [copyright ] [software ]