The first chapter of the book “The Power of PenPoint,”
PenPoint is a new operating system designed and built from the ground up by
GO Corporation for the unique requirements of mobile, pen-based computers. It
is a 32-bit, object-oriented, multitasking operating system that packs the
power of workstation-class operating systems into a compact implementation that
does not require a hard disk.
Shrinking hardware sizes and the addition of a pen make possible a dramatic
change in the way computers are used. Instead of controlling the computer through
a combination of mouse and keyboard, PenPoint proposes the use of a single,
simple pen. Instead of using computers only at desks or tables, PenPoint proposes
mobile usage throughout the day, wherever the user is: in meetings, standing,
walking, at a desk, in the car, even on the couch at home.
PenPoint computers are powerful, tabletlike devices that behave much more like a
notebook than traditional computers. Users control PenPoint computers with special
pens that are sensed by the screen. The user writes directly on the screen,
combining the convenience of a notebook with the power of a computer. Data
is entered by handwriting, which PenPoint translates into standard text. Commands
are issued by pointing and by gestures such as circling and scratching out.
In the early 1980s, the desktop personal computer market was only able to
flourish after the arrival of a standard operating system that allowed many hardware
companies to build systems that all could run the same application
software. In the 1990s, there is a need for a new, general-purpose, mobile,
pen-based operating system to play a similar role in catalyzing the opportunities
in the high-growth markets for mobile, pen-based computing. PenPoint is designed
to be that catalyst.
Our Friend the Fen
Under PenPoint, the pen is the primary input device. The pen is used for
pointing (by touching the screen), data entry (through handwriting), and commands
Using a pen, it is easy to make a simple gesture that specifies both what
you want to do (the operation) and what you want to do it to (the operand). This
results in a more natural, direct feel when using the computer. Take the
example of deleting a word. In a mouse-driven interface, you must doubleclick the
mouse to select the word, then choose Delete from a menu or the keyboard.
In PenPoint, you simply draw an “X” over the word, and it
is deleted. Gesture commands are difficult (at best) with a mouse. In
contrast, the pen is a single unified tool that combines the functions of a mouse and
keyboard and adds the new function of gesture commands.
The pen is the most natural and ergonomic computer input device. Humans are capable
of incredible precision and deftness with penlike devices: Walk into any museum
and view the artwork created with pencil, pen, and brush. This deftness is
possible because the pen allows the eyes and hand to coordinate closely. Furthermore,
the pen does not require an on-screen cursor, since the pen tip itself indicates
the pen’s location on the screen. Users are freed from learning about
the concept of cursors, which accelerates learning and improves efficiency in
using the system.
It is also important to recognize how comfortable meeting attendees are when other
people are writing with pens and how uncomfortable and distracted they are
by typing on keyboard-based computers. In other words, the pen is socially
acceptable in a wide variety of meeting situations. Furthermore, pen-based computers
can be used while standing and walking, while keyboards always require a table or desk.
Mobile Pen-Based Computing: An Untapped Market
In recent years, the growth rate of sales of desktop computers has slowed dramatically.
Even with a graphical user interface (GUI), computers remain difficult for most
people to learn and, because they are desktop systems, they cannot meet
the needs of the millions of American workers who spend most of their
day away from a desk. Despite the high sales rate of personal computers throughout
the 1980s, today only about one-third of the 78 million white-collar workers in
the United States use desktop systems.
Of those who do not use PCs, there are between 25 million and 35 million who
spend much of their time away from their desk. These users need mobile,
pen-based computers. Examples of these professionals include sales personnel,
lawyers, doctors, journalists, scientists, lab technicians, managers, executives,
estimators, inspectors, and field engineers. In addition, there are
significant numbers of blue-collar clipboard users and government workers who are
not served by desktop PC technology.
At the heart of these markets that will benefit from PenPoint is a new set
of tasks – that don’t belong at a desk or can’t be
performed there – as well as new users. Recognizing that there are
new tasks makes it easier to answer the often-asked question: “Will brand-new
customers or users of existing computers use mobile, pen-based computers?”
It will be both. While the dominant new market opportunity consists of the more
than 25 million new users who spend most of their time away from their desk
(if they indeed have one), there are many users of existing PC technology who
will benefit from these devices as well.
Because they are used for new tasks, and often by new users, pen-based computing
needs new application software suited for these new markets. Entire new categories
of applications such as meeting-aid software, note-taking, and group document
markup and revision will emerge. Applications that are limited in the current
PC market because they are deskbound (for example, calendars, personal-information
managers, and forms-completion systems) will flourish in the mobile, pen-based
market. They are all hampered in their market success so long as they must be
run on a desktop PC or laptop computer.
Pen-based computers will come in a variety of sizes and shapes. The pen
naturally scales to any paper size, so a variety of screen sizes makes sense.
Contrast this situation with the keyboard, which cannot be shrunk smaller than
typewriter size and still be usable. Depending on the task, users will buy
shirt-pocket, steno pad, notebook (page-sized screens), and desktop visual
tablet configurations of pen-based computers. Users interested in ultimate portability
for lightweight electronic mail, calendering, and personal-information management
would choose a pocket-sized device. Steno pads might be most appropriate
for on-screen forms completion. Users interested in serious document processing
will typically want page-sized screens. Lastly, graphic artists and CAD/CAM
users will probably prefer using a pen on a live screen in the visual
tablet configuration at their desk or drawing table.
The Laptop Isn’t a Solution
A common question is “Why aren’t laptops an appropriate solution
for the mobile market?” They aren’t because they are actually desktop
devices, not mobile devices. Laptops are evolutionary personal computers. Their
very premise is that they are 100 percent compatible with desktop computers
(that is, they must run the same software). They are therefore reduced-sized
desktop computers optimized for transportability (to move from desk to desk),
Like their desktop-based predecessors, laptop computers command the user’s
full attention during their operation. They simply cannot be made unobtrusive the
way a mobile, pen-based system can. When a laptop is placed on a table
or desk, the laptop computer must be opened up with the screen folding up into
the air. This intrudes into interpersonal space. Typing on a laptop keyboard is
intrusive in many group situations and therefore rarely done. And, of course,
keyboard computers cannot be used while standing or walking.
The real need is not for mobile, pen-based computers to run the same
software as desktop computers, but for them to have access to data files
stored on existing desktop computers and networks. Desktop operating systems do
a poor job of providing access to each other’s data files. In contrast,
PenPoint excels at providing access to a variety of desktop operating systems’
Why Build a New Operating System?
GO Corporation was founded in 1987 to pioneer mobile, pen-based computing. Early
in its development, GO Corporation determined that there were three major alternative
approaches to developing system software for this market. The first alternative
is to assemble a unique collection from standard pieces. This is essentially
what NeXT, Inc., has done: It took a version of UNIX and Display PostScript and
surrounded them with a variety of less standard pieces. This alternative has
the disadvantage that it does not bring along an installed base of applications and
that existing standard pieces were developed for the desktop and perform poorly in
a pen-based, mobile computing environment.
The second alternative is to add a “pen compatibility box” to an
existing Standard operating system such as OS/2 or Microsoft Windows.
The pen compatibility box would attempt to run existing mouse-based software by
using the pen to emulate the keyboard and mouse. While technically possible,
this approach misses the point of the pen: The pen can be much simpler to use
than the mouse and keyboard. When the pen is layered above a mouse-based GUI, a more
complex system results, not a simpler one. The user of such a system must ultimately
be fully aware of the underlying keyboard and mouse system and the mapping between
it and the pen.
The third alternative is to design and build a new operating system from the ground
up for the unique requirements of the mobile, pen-based market. This is the
approach that GO Corporation took. Today, PenPoint is available for applications and
hardware development activities.
There are a number of key requirements for an operating system for the mobile,
pen-based computer market.
The first key requirement is for a user interface designed to require only a
fraction of the user’s concentration; it must not presume the user’s
full attention will be focused on running the computer system, as desktop user
interfaces do. The user interface must also provide support for the pen through
gestures and handwriting translation.
In addition, applications on the pen-based system must be rewritten so they
can, wherever possible, supply context for handwriting translation. Only an
application can understand the meaning (semantics) of various regions of its
screen display. Therefore, when the pen is touched to the screen, the application
should be able to control the translation and meaning of the pen ink. For
example, only an application can specify whether certain fields it displays are
alpha or numeric. This simple information is vital in performing high-accuracy
Mobility brings a number of key requirements, including deferred data transfer,
detachable networking, and low memory and power consumption.
Deferred data transfer refers to users’ need to issue data transfer
commands on their schedule, not the computer’s. With laptop computers,
users must wait until they have an actual connection to a network, telephone
line, or printer before they can give an electronic-mail, print, or facsimile
command. Users must therefore perform the clerical work of keeping lists of file
names to send or print when the appropriate facilities become available. This
is burdensome. It is much more efficient to allow users to “address”
the electronic-mail message when they’ve finished composing it; the user
can then be free to move on to the next task, and the computer can perform the
clerical task of tracking pending operations. An operating system for the
mobile, pen-based market must provide mechanisms for deferred data transfer.
Detachable networking refers to the need for users to be able to make and
break networking connections at will. In addition, the operating system must
support multiple network protocol stacks so that the same pen-based machine can
talk to many types of computers and networks (including wireless) in the course
of a single day. When a connection is temporarily broken, the system should
gracefully suspend the connection and be ready to resume it again when
the connection is remade.
An operating system for the mobile, pen-based markets must excel at
data compatibility with many existing personal computer and networking
standards. Interestingly, a new operating system can actually do a better
job at this than an existing one. Existing operating systems tend to be compatible
only with themselves, creating islands of data without bridges. A new
operating system can be designed to be promiscuously compatible and connectable.
Memory and power consumption needs must be minimized, not maximized, by
an operating system. Desktop operating systems and applications are
rapidly growing to fill all space available on large hard disks. These large
hard disks are not always small enough or durable enough for small, pen-based
computers that can get knocked about in use. Therefore, pen-based computers
require a system that can minimize total memory requirements, including disk
space. Also, the operating system must include sophisticated power management
because batteries are a significant portion of the weight of pen-based computers.
Any successful operating system must provide a rich development environment.
While existing systems have a head start on building a collection of tools
and trained programmers, a modern, object-oriented operating system can do the
best job of this. This is because it can provide the most-productive coding
environment for the applications developer, since its application programming
interfaces (APIs) will be consistent, coherent, and provide the right
functionality for the new market. In contrast, traditional desktop operating
systems are increasingly burdened with the complexity that stems from piling
layer upon layer of software.
Finally, since the mobile, pen-based computer market is new, any operating system
choice must provide a strong foundation upon which an entire new market
can be built. The operating system must incorporate proven, robust technology
choices such as 32-bit addressing, flat-memory model portability, and object orientation.
What Is PenPoint?
To understand PenPoint, you must grasp the significance of three adjectives:
general-purpose, mobile, and pen-based. A general-purpose operating system is
essential because computer markets naturally seek out general-purpose system
software; no one wants to buy a vertically integrated solution that ties
hardware, system software, and applications together into a single-vendor
solution. Mobility is vital for the markets of people who spend most of
their time away from the desk. Pen-based operation means that applications and
system user interfaces are extensively rewritten to take advantage of the pen.
General Purpose versus Special Purpose
New technology markets are usually first served by special-purpose solutions.
In the computer business, these take the form of vertically integrated
hardware/system software/application combinations such as the dedicated word
processors from the early years of microcomputers. On the inside, they
were personal computers, but they lacked a general-purpose operating system.
Instead, they incorporated special-purpose system software.
MS-DOS and the IBM PC put a nearly complete halt to dedicated word processors.
Markets naturally loathe special-purpose solutions and favor those based on
general-purpose operating systems, because customers would always rather spend
a little more money and gain freedom of choice of applications and freedom
of choice of hardware vendors.
PenPoint is designed to be a general-purpose operating system available to
the market on many different hardware platforms. Any PenPoint application will
run unchanged on all PenPoint hardware.
Notebook User Interface
PenPoint was designed to be driven primarily by a pen. Because of this,
PenPoint includes many new elements not found in traditional GUIs. Three
of the most important are the notebook metaphor, gestures, and
powerful handwriting translation. Together, these constitute the Notebook User
The notebook metaphor in PenPoint provides the user with a simple-to-operate,
on-screen Notebook (see Figure 1-1). The user’s information is organized
as a collection of pages and sections. Tabs appear at the right-hand side of
the screen, and there is a Table of Contents at the front of the Notebook.
At the bottom of the screen is the Bookshelf, a repository for systemwide objects
and resources such as In Box, Out Box, and on-line Help.
(Chapter 2 describes
the notebook metaphor and other aspects of the NUI in detail.)
|Figure 1-1. The Notebook Table of Contents|
We have already introduced the idea of gesture commands. PenPoint’s NUI builds
in a standard set of powerful gestures that work consistently across all applications.
PenPoint’s handwriting recognition system insulates applications from the need
to develop any form of pattern-recognition techniques. Yet it allows those
programs full control over the translation process, which is essential in
attaining true pen-based user interfaces. While the user writes, PenPoint
performs the recognition process in the background, so that the resulting text
can be displayed immediately after the user signals that all of the text has been entered.
All applications written for PenPoint must adhere to PenPoint’s Application
Framework (discussed in detail in Chapter 6), which is a set of protocols
rigorously defining the structure and common behavior of a PenPoint application.
Through the Application Framework, applications inherit a wide variety of standard
|gesture recognition and response
|copy and move data transfers
|live embedding of other applications
|installation and configuration
|creation of application instances
|search and replace
|import/exporting file formats
|application life cycle
New code is required only to add functionality or to modify or override specific
aspects of the default behavior. Use of the Application Framework thus yields
significant savings in programming time and code space.
The Application Framework defines the standard components of an application, including
the application’s code, an application object that is the control center
for the application, a resource file, instance directory, process, and a main window.
Applications have a well-defined life cycle comprising six phases
|creation (create document state in file system)
|activation (create process)
|opening (turn to page)
|closing (turn away from page)
|termination (kill process)
|destruction (delete document state from file system)
In addition to normal applications that run when their page is turned to,
PenPoint provides a Service Manager architecture that supports background server
applications such as databases and network connections. Applications can
interrogate PenPoint as to the presence of services and then establish
message-passing connections to these services. For example, a personal-information
manager application might provide many views onto one large collection of textual
and calendar information. Each view would reside as a page in the Notebook.
Actions in one view (your personal calendar) can thus be reflected instantly in
another view (your project schedule).
Applications save their internal state in a directory in the file system, but
this is invisible to the user, who has no need to save or load the application’s
state explicitly from one session to the next.
Embedded Document Architecture
The most innovative aspect of PenPoint’s Application Framework is its
Embedded Document Architecture (EDA), which provides three key user benefits:
the document model, live application embedding, and hyperlinks.
The Document Model
In PenPoint, the operating system performs the clerical bookkeeping steps of
starting and stopping processes (running applications) and of loading
and saving application data. This is called a “document” model because
the user never deals with application programs and data files or with the need
to associate the two by loading files. Instead, users simply move from page
to page and always see their data just as they last left it: scrolled to
exactly the same location and with the application apparently still running. Unless
the user is transferring information to other computers, there is no need
for the user to deal with separate files and programs. Instead, to the user’s
mind, each document is itself a live, running piece of the user’s data.
Live Application Embedding
Live application embedding refers to PenPoint’s capability to embed
a live instance of one application inside another application. It is PenPoint’s
most unique technical innovation.
For example, a text document can, with no special programming on the part of
its creator, embed any other PenPoint application, such as a spreadsheet
or business graphics application, within a text document it creates.
Figure 1-2 shows a text document with two embeddees: a live, running drawing
program and a live, running signature pad (which is, by the way, a built-in
PenPoint object), both with their borders turned off. The result is that
all PenPoint applications can provide a true compound document capability in which
users are free to mix and match applications seamlessly.
|Figure 1-2. Text Document with an Embedded Document|
The pen is an inherently multimedia tool; nothing is more natural than quickly
switching from writing numbers to writing words to drawing a sketch,
all on one piece of paper. PenPoint’s live embedding allows every
document in the PenPoint Notebook to be a compound or multimedia-ready,
Other operating systems copy “dead” data from one application
to another. This requires the designer of the receiving application to
write code to accept a variety of data formats from the Clipboard and
dynamic data exchange (DDE) transfer mechanisms. While PenPoint supports this mode
of transfer of pure data, the norm is for the receiving application simply
to embed an instance of the application that already knows how
to edit and display the data.
Hyperlinks are a standard element of PenPoint’s EDA. PenPoint provides
a simple gesture with which a new hyperlink button can be created. The
resulting button will “jump” (a combination of turning pages
and scrolling a document) to the location selected when the button
was created. Users can rename buttons and place them anywhere in the
Notebook. Since PenPoint supports live embedding, the buttons can be placed
inside documents as well as in PenPoint’s Bookshelf area. The
result is a hyperlinking mechanism that is completely integrated with both the
operating system and all applications written for it.
From what we have said, it should be clear that PenPoint applications and
the operating system have a close relationship with one another. The
user might form the impression that installed applications and the operating
system are simply part of a seamless whole. But the two are, in fact,
cleanly separated. This allows easy distribution, installation, and deinstallation
of PenPoint applications by third parties.
PenPoint comes with one built-in application, the MiniText editor, which is
a pen-aware formatted-text editor. It is available for all applications to
reuse, saving them the work of coding their own text editors.
Otherwise, as a general-purpose operating system, PenPoint applications will typically
be bought by end users and added to their PenPoint system, just as MS-DOS
and Macintosh applications are today.
PenPoint’s standard for application distribution is 1.44MB, 3.5-inch
MS-DOS disks. Every PenPoint-capable machine has access to such a drive
(either built-in, via a base station, or through a desktop system). When the
user places an application distribution disk into the drive, PenPoint automatically
senses it and displays an application installation dialog box. If the
user confirms a desire to install or update the application, PenPoint
handles the rest. All needed application code and resources are installed into
the PenPoint machine. Application code is also relocated at this time.
PenPoint will also ensure that all classes required by the application are installed
and are of the correct version.
PenPoint excels at connectivity to a variety of computers and networks.
Mobile connectivity requires an operating system to be different from existing
desktop operating systems, which evolved in a world of static connectivity.
Desktop Operating System = Static Connectivity
Desktop operating systems are designed for a world in which a single
network connection is present all day. While this makes sense for
desktop machines, these limitations are inconvenient for laptop users and
unacceptable for mobile, pen-based computers.
Desktop operating systems can typically load only a single network protocol
at a time. For instance, with an MS-DOS laptop, no matter how small it
is, you have to change start-up and configuration files and reboot your computer
to connect to and disconnect from your office network. If you unplug the
network wire without rebooting the system, you may lose data or crash
the desktop operating system. These are the limitations of a static connectivity design.
PenPoint provides smooth connectivity to other computers and networks
through built-in networking APIs that go well beyond the file transfer
utilities currently used for laptop computers. PenPoint’s networking protocols provide
access to file system volumes, printers, and other remote services
provided by desktop personal computers and networks.
Mobile, pen-based computers are connected and disconnected many times a
day, often to and from different computers and networks. For these
reasons, PenPoint supports multiple, “autoconfiguring” network
protocol stacks that can be dynamically installed without rebooting the
operating system. Network connections can be established and broken at
will by the user (in other words, the user simply plugs cables in
and removes them or walks into and out of receiving range
for wireless communications), and the operating system and applications handle
the breaks gracefully, suspending all interruptible operations until the
connection is reestablished.
PenPoint’s Out Box allows users to initiate file transfers, send
electronic mail and facsimiles, and print documents to any destination,
regardless of where the user is and regardless of whether the pen-based
computer is currently hooked up to a connection that could satisfy the command.
The Out Box is a central, extensible queueing service for all
connection-dependent transfer operations. Transfer agent services that extend
the Out Box to work with specific destinations such as printers, file
transfer, specific electronic-mail protocols (MCI Mail, PROFS, MHS,
and so forth), and facsimile can be installed. The user interface for the
Out Box is a small floating Notebook that provides a section for each
Out Box transfer service.
Outgoing information must, of course, be addressed. PenPoint supplies standard
Print and Send commands that allow communication services to be tightly
integrated with PenPoint applications. The Send command brings up
service-extensible addressing mechanisms that allow the user to send a
single document to multiple destinations. PenPoint provides a standard
address-book API so that the user’s favorite address-book application
can be used to store addressing information integrated with the address-book
information the user keeps for all other uses.
Few people have the time to read all their electronic mail at their desk
when they’re plugged into the network. PenPoint’s In Box
supports quick downloading of all received mail and facsimiles, so users
can disconnect and carry their mail with them for perusal between meetings
or at home in the easy chair. The In Box architecture is symmetrical to
the Out Box and is similarly extensible by installable transfer services.
PenPoint’s file system is designed for compatibility with other existing
file systems, particularly MS-DOS, and includes full support for reading
and writing MS-DOS-formatted disks.
The PenPoint file system is tied to the MS-DOS file system; all
PenPoint-specific information is stored as an MS-DOS file in each
MS-DOS directory. This approach is used when mapping to other file
systems as well. Additional, installable volume types are also supported.
Compact and Scalable
Desktop operating systems assume large, cheap mass storage and therefore run
poorly or not at all in one-tier hardware (RAM only, no mass storage)
or require prohibitively expensive amounts of RAM to simulate disk space, or
require difficult-to-update ROM memory. Although small applications exist for
desktop operating systems, most of the best-selling applications typically
require several megabytes of disk space.
In contrast, PenPoint is designed to run as a single, standard operating system
on a full range of pen-based hardware, providing the largest possible market
for applications. PenPoint runs well on both one-tier and two-tier (RAM
with mass storage) memory architectures. As a result, PenPoint users will
have a choice between small RAM-only machines and slightly larger machines with
or without hard disks.
PenPoint’s object-oriented design achieves compactness through a high
degree of code sharing. Furthermore, PenPoint keeps only a single copy of
code in the computer, because it relocates executable code at application
installation time, not at application load time, as is traditionally done.
If applications are relocated into memory at load time, there must be
an additional copy of unrelocated application code on the disk. This, in
effect, doubles total memory requirements. Once PenPoint installs an
application, only a single copy of its code (the relocated executable) resides
in the PenPoint machine until the user deinstalls that application.
PenPoint applications are small compared with their desktop counterparts.
Competitive PenPoint applications often require total storage space of only
100 to 200 KB, rather than the megabytes that existing disk-based applications require.
Because PenPoint hardware will vary in screen size from shirt pocket
up to large desktop visual tablets, PenPoint provides full support for all PenPoint
user interfaces (including applications) to automatically adjust and scale to
a variety of screen sizes. PenPoint’s User Interface Toolkit allows
applications to specify their user interfaces in the form of a relative
constraint language. PenPoint then calculates the actual size and position
of all user interface elements during program execution. As a result,
applications do not hard-wire screen-size dependencies, as they have in
the MS-DOS world.
A Solid Foundation
Combined with its unique support for the pen and mobile computing and
its compact implementation, PenPoint is a platform that can provide a
large and growing market for applications well into the next century.
All of PenPoint’s APIs are 32-bit, and the first commercial version of
PenPoint will run on the Intel 80386 processor in its native, 32-bit,
flat-memory mode. In addition, because PenPoint is written in C and is
designed for portability, it can be ported to a variety of other processor
architectures, including high-performance, low-power RISC (reduced instruction
set computing) chips.
PenPoint provides preemptive multitasking similar to OS/2’s, enabling
smooth user interface interactions, background communications, and smooth
background translation of handwriting while the user is writing. Each application
runs in its own process. Lightweight child threads are supported.
Reliability is crucial to the mobile, pen-based market. PenPoint therefore
takes full advantage of available hardware memory and hardware process
protection to provide a reliable and robust environment. If an individual
application or process crashes, the rest of the system keeps on running.
Even if PenPoint itself crashes, it provides an on-the-fly diskless “warm
boot” that preserves all user Notebook data and application code
and returns control to the user within one minute. Companies can count
on PenPoint for their most critical field applications.
Although we’ve seen that PenPoint requires little storage space, it can
run equally well in high-end configurations with large amounts of memory.
PenPoint can directly address up to four gigabytes of physical memory.
Furthermore, PenPoint incorporates paged virtual-memory support, allowing it to
work efficiently in architectures that include backing store, such as desktop
hard disk machines.
Software developers today are forced to write ever larger applications because
today’s operating systems require every application to be self-sufficient
and monolithic. As a result, small developers are increasingly locked
out of the commercial application marketplace since large, monolithic applications
generally require either large programming teams or long development cycles.
PenPoint changes the equation in favor of smaller development teams by
providing an object-oriented environment in which applications can build
upon each other and share large amounts of functionality.
The event-driven, object-oriented nature of the system minimizes the
need to “reinvent the wheel” with each new application. PenPoint’s
APIs are implemented using object-oriented programming techniques of subclass
inheritance and message passing. PenPoint provides more than 250 classes
and 1,500 messages for use by the application developer. Programmers
can code by exception, reusing existing code while altering or adding only
the specific behavior and functionality their own applications require.
Because the object-oriented architecture is systemwide, these benefits are not
restricted to single applications; in fact, applications can share code
with each other just as readily as with the system itself.
This chapter has introduced the key concepts behind the PenPoint Operating
System. As we have seen, this new operating system was created to respond
to the unique needs of pen-based computing. Specifically, these needs
demand a general-purpose, mobile operating system.
PenPoint responds to these unique needs with such features as:
|Notebook User Interface (NUI) – PenPoint’s central organizing concept
consisting of pages, tabs and a table of contents. In addition, a
new but familiar language of gestures and powerful handwriting recognition completes
|Embedded Document Architecture (EDA [TM]) – PenPoint’s EDA lets
the user embed live, editable documents within other documents and create
hyperlink buttons between any two locations in the notebook.
|Mobile Connectivity – Instant-on, detachable networking and deferred
I/O permit truly portable computers for mobile workers.
|Compact and Scalable – While expressly designed for small
light-weight, portable computers, PenPoint is highly hardware independent and
scales to a variety of sizes, from pocket-size to wallboard-size computers.
|Rich OS for the 90s – A true, 32-bit, flat-memory model architecture
with pre-emptive multitasking and a powerful, compact imaging model, Imagepoint™.