First Looks at Slate’s PenApps and The Rogue PenApps Workbook

An exciting era of software development is starting to hit its stride — visual programming. No longer in the dark shadows of its more powerful and sophisticated predecessors, modern visual programming environments are beginning to define their own ground rules and are enabling a whole new class of application developers to tackle an ever expanding range of problems. As these systems become widely available for pen computing systems using either GO’s PenPoint and Microsoft’s Windows for Pen Computing, we can expect a host of new and exciting pen-based applications.

In this article, we’ll take a first look at one of these systems: PenApps from Slate Corp. We’ll also examine The Rogue PenApps Workbook, an innovative tutorial from Young Ideas, a Sausalito CA software developer which can help beginning to intermediate programmers come up to speed in this new environment.

PenApps is MultiPlatform

Slate Corp.’s PenApps has been available to programmers since March 1991 when it was first released for PenPoint, even before PenPoint 1.0 was officially released. One of the most appealing features of PenApps is its availability on both major pen-based environments, PenPoint and Pen Windows.

On either platform, PenApps presents a comfortable and intuitive visual development model. Developing applications consists of two steps: constructing the user interface by sketching out the forms and dialog boxes that make up the application, and supplying the code that responds to user and program-driven events. As with most visual development tools, PenApps is event-driven, requiring code to instruct the program on how to respond to a user’s action.

Starting from the TRS-80 and Apple II, BASIC has formed the core of many interpretive development systems. Recently, Microsoft created an exciting interactive environment in their flagship Visual Basic, portions of which were developed by Cooper Software. So it seems only natural that PenApps would also use a dialect of BASIC appropriately called Slate PenBasic. Using this language, a developer writes the code which defines the behavior of the objects (buttons and fields) that make up an application.

In the past, PenApps has also one-upped its most visible competitor by including a high-performance database engine in the system. Microsoft has recently remedied this highly-visible shortcoming by adding its own database in the 3.0 version of Visual Basic.

My first impressions are that PenApps should prove to be useful for creating both proof-of-concept applications along with certain limited-distribution commercial programs. However, the true strength of these environments lies in its interpretive development model, which enables programmers to learn the system through experimentation and also develop applications through a series of rapid prototyping and refining.

When used like this, PenApps will probably find its home with in-house vertical application developers at companies of all sizes. Companies are always looking for ways to leverage their most expensive resource — their human talent — and are expecting the development system itself to help reduce both the learning and the development cycles for these risky new pen-based applications.

Built-in Pencentricity

Slate has properly recognized that much of the risk of developing new mobile systems centers around the relative inexperience that many developers have with these new pen-based systems, doubly so when they also have to learn a complex new environment like PenPoint or Windows. Slate hopes to help developers in both camps by encoding as much of an application’s pencentricity within PenApps itself. This should reduce the burden on the developers, enabling them to concentrate on solving the problem at hand. At first glance, PenApps seems to have the muscle to deliver on these expectations.

Slate’s pencentric features built into PenApps includes:

• Input Targeting, enabling users to write outside the borders of a field and have the program correctly position the input text
• Markup Mode, which enables freehand annotations to forms-based applications
• Gesture Support, enabling special gestures to control the flow of the application
• Cursorless Operation, enabling a user to fill in a form in no particular order without the need to set a focus or cursor in a field

• Ink as a Data Type, which stores input as ink along with the translated text
• Switch to Ink, enabling users to switch back to ink to verify translation at a later time
• Deferred Translation, allowing translation to be initiated at a more convenient time

The End of Painful Development?

Certainly, one of the main advantages of PenApps is that it frees the developer from the painful compile, link, test, and edit cycle that serves no use other than to consume time. This cycle is especially wasteful when developing for PenPoint since application development takes place under DOS, forcing you to repeatedly bring the system up and down on a single machine. In this case, PenApps brings the entire development procedure under the native PenPoint environment. In either environment, PenApps enables you to perform run-time testing of your application by simply tapping an icon. After completing the application, you can build a regular executable version of the program for use outside of PenApps.

Creating an Application

The method for creating an application is straight-forward. For this article, I’ll describe the procedure using the PenPoint version of PenApps. However nearly all the skills you develop in one environment can be carried over to the other. Any differences lie mainly in the particular user interface conventions and gadgets available. You begin by creating a new PenApps page in your notebook using the familiar caret gesture. When you turn to this page, you are in the development environment and ready to create the user interface for the application.

PenApps displays a floating Tools palette from which you can select the user interface components of your program including free-form and combed input fields, check boxes, buttons, and list boxes. You can also draw lines, rectangles, and ovals to frame sections of the interface, and you can supply text to label them.

Writing the “C” gesture over any object brings up its associated code window. Using this code window, you can specify the object’s action and data “slots.” In PenApps, an action slot contains the code executed when an event is triggered. These slots include events such as OnTrigger, OnReceiveGesture, OnValueChanged, and others. A data slot, on the other hand, contains the current property settings for the object. These properties vary with the object but include things such as the width, acceleratorKey, displayOnly, and others.

As a test of the environment, I sketched a simple form to collect several pieces of information. The ease with which I could test the application really encouraged me to quickly refine even this simple program. Building a stand-alone version was equally straight-forward — there is a Build Stand-alone option in the Document menu. PenApps prompts for a file name and volume in which to store the executable. Installing and running the completed application worked without flaw.

Differences between Platforms

Since PenApps is also available for Windows for Pen Computing, PenApps has the rare distinction of being a multi-platform pen-based environment. With a few restrictions that center mostly on special features of each of the two operating systems, you can import and recompile an application created on one platform on the other with little effort. The exceptions that do exist are based on extended features in each system architecture. For example, Windows doesn’t offer native support for PenPoint’s Embedded Document Architecture making this feature untranslatable.

PenApps stores the forms, properties, layout information, and slots in special project files which can be migrated between the platforms. Likewise, the PenBasic code executes identically on both environments making the transfer straight-forward. The Reference Manual that comes with the package is particularly good at pointing out potential trouble spots by identifying any platform-dependent features using either a PenPoint or Windows icon.

End User Apps Require Runtime

One questionable aspect of developing using PenApps comes when it’s time to deploy the application in the field. Under the terms of the licensing agreement, every PenApps application must include a copy of either PenApps or the PenApps Runtime. The Runtime module can be purchased from Slate in single quantities at $49. Slate also offers quantity discounts and an unlimited site license for $2995. This is in sharp contrast with Microsoft’s policy of allowing application developer’s to ship a copy of the Visual Basic runtime free.

I’m pleased with the operation and performance of the product in both environments. While my sample application did little to stress the environment, it was reassuring to find that the simple things were indeed simple to perform. The ability of the product to perform nearly identically on the two leading platforms is impressive, but I wonder how important this feature is to programmers and developers who are likely to standardize on a single pen system early in their work. In addition, it will be interesting to see whether Slate eases its position on demanding runtime licensing fees, something I feel is likely to hurt a nascent market more than it helps.

The Rogue PenApps Workbook

PenApps is an intuitive environment whose operation should be familiar to anyone who has worked with Visual Basic or one of the other visual development systems. However, PenApps also include some subtleties that are usually best explained by a capable mentor or instructor. Since these people are rare, the next best alternative is to work through a series of examples using a well designed workbook. In the case of PenApps, this need is satisfied by The Rogue PenApps Workbook created by Catherine Young at Young Ideas.

Young is a software consultant in the San Francisco Bay Area and has been active in the pen industry since 1991. She has followed the progress of PenApps through each of its stages from the Developer’s release, various alpha and beta programs, through to the current commercial versions of the program. She has also taught courses in PenApps programming both here and in Germany. Her company, Young Ideas, has an extensive list of clients both in and outside the pen industry including IBM, GO Corp., Slate Corp., Kaiser Permanente, and Ziff-Davis.

The Rogue PenApps Workbook is actually a combination of a spiral-bound manual and a 3 1/2″ disk containing a sample database. The workbook is geared towards developers using the PenPoint version of the system, and highlights information on how to utilize the native PenApps DBMS (the PenApps database engine), and the add-on xBase database system. The workbook is divided into nine exercises: eight focusing on the native database, and one on the xBase engine. Each exercise is well written and nicely presented in a format you would expect for a workbook.

I particularly appreciated the time estimates at the beginning of each exercise which gave me a sense of how much work was ahead before finishing. The exercises range from 30 minutes to nearly 2 hours (115 minutes), with most falling between 45 and 60 minutes, which I believe is suitable for this type of self-study. The exercises describe how to create a moderately complex forms-based application accessing a PenApps database with information about monsters complete with graphics. This light-hearted addition makes the exercises more interesting, and a little less abstract, as I was curious to see which monsters were included in the database.

The exercises themselves include many of the features and skills needed to work with PenApps. For example, one exercise lets you practice with the on-screen tools, another instructs how to change the object settings, while another shows how to program the behavior of the objects. The workbook also includes an exercise to help you develop debugging skills within PenApps, something there is little native support for in the environment.

The workbook itself has a pleasant structure and style which makes it interesting to read. Each exercise begins with an objective and description from which the reader is expected to complete the task. On the following pages, a step-by-step series of hints describes how to perform everything given in the description. Young makes very effective use of screen captures and illustrations for many of the steps, something that is essential when describing a visual environment. The detail in the workbook also shows that the written material was tested against the actual environment before release.

While the workbook is well thought-out and constructed, there are a couple of points which could use improvement in a subsequent version. In particular, the workbook includes a section entitled “Tips and Techniques” that appears before the first exercise. I found some of the material in this section overly detailed and arcane, especially for someone new to PenApps. This section also contains a handy page entitled “How to Program and Run PenBasic in Ten Steps.” While I realize that this page is intended to serve as a reference to later exercises in the book, I found myself more confused than helped at this early stage.

Overall, The Rogue PenApps Workbook is a well-written tutorial and self-study guide that should be useful to people who want to learn how to effectively use the PenApps environment while performing a task-oriented series of exercises. Young sprinkles useful design considerations throughout the book which illustrates her understanding of building usable pen-based software.

For more information, contact:

Slate Corporation
15035 North 73rd Street
Scottsdale, AZ 85260
Phone: (602) 443-7322
Fax: (602) 443-7325

Young Ideas Software Design Services
207 Second Street, Suite B
Sausalito, CA 94965
Phone: (415) 331-3128
Fax: (415) 331-9620

John Jerney is President of Volksware, Inc., a company developing software for both PenPoint and Windows for Pen Computing. He can be contacted at [email protected].