The first chapter of the book “The Power of PenPoint,” pp. 1-19.

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 (through gestures).

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), not mobility.

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’ data files.

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.

Key Requirements

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 handwriting translations.

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 Interface (NUI).

Figure 1-1. The Notebook Table of Contents

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.)

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.

Application Framework

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 behaviors, including

	gesture recognition and response
	copy and move data transfers
	live embedding of other applications
	view-data model
	installation and configuration
	creation of application instances
	on-line help
	document properties
	spell-checking
	search and replace
	printing
	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.

Figure 1-2. Text Document with an Embedded Document

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.

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, paperlike surface.

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

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.

Applications

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.

Mobile Connectivity

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.

Summary

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 the NUI.
	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™.