History of the Windows
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
- 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
- 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
- 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
- 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
[contact ] [copyright
] [software ]