[Please note: this is a text only version of the on-line magazine, OS/2 e-Zine!.  OS/2 e-Zine! is a graphical, WWW OS/2 publication and, if possible, should be viewed in its HTML format available on-line at http://www.os2ezine.com/ or zipped for off-line reading.  Some graphically oriented articles have been removed from this document.]

OS/2 e-Zine!		March 16, 1999	volume 4, number 4
--------------------------------------------------------------------------
Copyright 1998		Falcon Networking	ISSN 1203-5696

	"Over Three Quarters of a Million Satisfied Visitors!"



Reviews:

*XFree86 In OS/2:*

Open up the floodgates to a wave of new software for OS/2, just by installing a free X server. We'll show you
how to download and configure XFree86 for OS/2 correctly, plus we'll also be showing you what software you can
use with it.
* Installing XFree86/2 - Chris Wenham 
* Installing GIMP/2 - Chris Wenham 


Articles:
* Why OpenSource? - Ulrich M&ouml;ller 
- The author of the popular XFolder enhancement utility speaks out on what his reasons were for switching to an Open Source model, and makes a plea for other freeware developers to do the same. 

* How To Make Money With OS/2 - Bob St. John 
- How a simple consultant can sell OS/2 as a service rather than a product and bypass the whole 'OS/2 or Windows?' question entirely. 

* Rexx Newbies - Chris Wenham 
- Functions let you take advantage of pre-written code that you don't have to understand the workings of. Nifty stuff, but first we'll show how to make a simple one of your own. 

Opinions:

* Chris' Rant

Departments:

* The Rexx File 

ADMINISTRIVIA:

* How to Subscribe to OS/2 e-Zine! for FREE.
* How YOU can Sponsor OS/2 e-Zine!
* The Sponsors that Make this Issue Possible

Copyright 1999   -   Falcon Networking
ISSN 1203-5696

***********************************

Chris's Rant  - Chris Wenham

Summary: Is there such a thing as a brain-dead user? Can a human being really be this dumb? Or is it not a problem inside *their* head, but in *ours*?

_Stupid Users_

There are CD mastering programs available that assume a silence of two seconds marks the end of one track and the beginning of another. Give it a subtle piece of classical music and the "feature" will turn a single symphony into a dozen or more tracks that waste the disk and break up your listening pleasure. It was made because the developer assumed its users would be too stupid to figure out how to tell the program where a track began and ended, but was that the case, or was the developer too stupid to come up with a better mechanism?

A telephony package for windows designed to be your answering machine, phone dialer, address book and all-round communications center tries to mimic a desktop telephone as visually as it can. When you want to answer an incoming call you click on a huge picture of a telephone handset. When you want to play answering machine messages you click on the "Play" button underneath a picture of a tape deck. It uses scads of desktop space and the time spent crafting the pictures of these instruments obviously ate into the time the developers could have spent making its built in address book integrate with the other tools that were mere pixel inches away. They did this because they thought their customers would be too stupid to use anything that didn't resemble what they were already familiar with, but was it more because the developers were too stupid to come up with something more intuitive, and yet more sensible than a lot of pictures that don't -do- anything?

It occurred to me, after looking at Lotus Organizer side by side with Just About Anything Else, that attempts to dumb down software are attempts to make the users dumb, not cater to users who are dumb. My theory is that there is *no such thing* as a dumb user.

I could challenge the likes of that guy who wrote that book about the Bell Curve (who needs a kick in the ass), but rather than waffle on about heredity and environment I'll put it this way: The person who used his CD-ROM tray for a retractable coffee-cup holder at was at least intelligent enough to find a new purpose for it, and the company that sold him that computer was so dumb that they didn't even put simple *labels* on their uniformly beige boxes.

There's a reason why toy Superman costumes now come with labels that warn "Garment does not allow wearer to fly" and it has a lot to do with the way 5 year-olds got very put out when they discover their G.I. Joe action figures don't walk and talk on their own like they did in the commercials. It also has a lot to do with the way I suffered chagrin and disappointment at the age of 6 when a breakfast oatmeal product didn't cause an orange aura to form around my body like they did for the kids on TV. The kids aren't stupid, the commercials and toy makers are.

And some people do go to a dictionary to see if the word "gullible" is listed or not, and some people do wonder if a "computer virus" can be caught by a human. It isn't because they're dumb, it's because they're *smart*. They're applying a limited working knowledge to the new information they've been presented, just as a human brain is supposed to do. They're also making use of trial and error and if one of their errors is an embarrassing one ("Press control, eh?") then they're all the more likely to learn from it. Like a wise man said: the rate at which one matures is directly proportional to the embarrassment one can endure (and fixing someone's fear of embarrassment could be as simple as *not laughing at them* when they screw up).

Software and hardware could be simplified much more than it currently is, but it could be that developers are pursuing this for the *wrong reason*. A rocket scientist can still benefit from a "single click" scan-and-fax program just as much as grandma could, but a developer simplifying for the wrong reason might also remove all DPI and brightness controls too -- frustrating the heck out of an industrial designer. Or the developer could be like the one who wrote the aforementioned CD mastering program - adding a feature convenient for recording Top 40 songs but ridiculous for Bach's *Toccata and Fuge* - and removing one's ability to switch it off because it would make the software "too complicated".

It quite possibly never occurred to developers, who are so afraid "dumb" users will open the settings and start messing around with check boxes, that a short sentence at the top of the dialog explaining "You probably won't need to alter these settings unless you are recording music with lots of subtleties, such as classical or electronica" would do more for usability than removing the options completely and bludgeoning the customer with stupid defaults.

It also possibly never occurred to developers that instead of spending hours in front of Borland Resource Editor to paint gorgeous replicas of handsets and leather binders and tape decks, they could be using that screen estate to display more information, better controls, and context sensitive help. The Warp Guide was a step in the right direction as far as this is concerned: put the help -in- the interface!

Better documentation, and documentation put in the -right places- will fix "clueless user" problems fast. It may then begin to dawn on us all that the only difference between the computer savvy and the computer stupid was who got their hands on one first.

***********************************

The Rexx File  - Dr. Dirk Terrell

Summary: Just a quickie this month. Dirk shows how to open a desktop folder from the command line.

This month I'll share with you a simple script but one that I use many times a day. I call it "of.cmd", the "of" meaning "open folder." The reason why I find OS/2 so much better than other operating systems is that it has both a powerful graphical user interface and a powerful command line interface. With Rexx you can build some powerful connections between the two. The of.cmd script allows you to open the WPS folder for a specified directory or the current directory if one is not specified.

Because of the extensive functions of the RexxUtil library that comes with OS/2, this script is actually very simple. All we have to do is use the SysOpenObject() function to open the directory of interest. The first step is to load the function from the RexxUtil library:

Call RxFuncAdd "SysOpenObject", "RexxUtil", "SysOpenObject"

The next thing to do is parse the command line arguments for the directory to open. If none is specified, we will open the folder for the current directory:


Parse Arg Directory .
If Directory="" then Directory=Directory()
View="ICON"


The Directory() function, when called without parameters, will return the -current- directory. If the user doesn't specify a directory, then variable named 'Directory' will be null, so we test on that and assign the return value of the Directory() function to it if it is null. Note that when a directory is specified, it must be a full path, including the drive letter, e.g. c:\os2.

Now that we know which directory folder we want to open, all we have to do is make the call to SysOpenObject():


call SysOpenObject Directory, View, 1
call SysOpenObject Directory, View, 1


And no, that isn't a typo. We want to call the function twice. The first call opens the folder and the second one gives it the focus. And that's all there is to it. Maybe you will find this little script as useful as I do. Some things more easily done from the command line and others are more easily done with the WPS and this script gives you quick access to WPS objects from the command line.

***********************************

Installing XFree86 in OS/2  - Chris Wenham

Summary: What can you do in half an hour that instantly adds access to a staggering new array of software in OS/2? Install XFree86, that's what. This is a free X Window server that isn't actually that hard to install and configure.

There's a good reason to get some kind of X Window server onto your OS/2 system today: Software. Lots of it. A large number of applications born on Unix have been ported to OS/2 thanks to the work of Eberhard Mattes (for EMX) and Holger Veit (XFree86 for OS/2). EMX filled in many of the "gaps" in OS/2 that Unix programs were written to expect, instantly opening the gates for a flood of mostly character mode and command line utilities that either stayed that way, or gained PM (Presentation Manager) front ends. Later, building on what EMX had laid, XFree86 came along and opened another set of gates - this time for graphical Unix software. What's available right now, and what's only a compile away, is a huge number of software titles.

Now even though a couple of XFree tutorials have popped up on the web recently (such as in the (http://www.os2voice.org/VNL/past_issues/VNL0299H/vnewsf2.htm) VOICE Newsletter for February), we decided to risk accusations of unoriginality and produce one of our own. Since we'll be discussing X applications in more detail in the coming months we felt it'd be appropriate to introduce our readers to it in this way.

But before we install XFree we should first describe what it is. Developed in the mid 80s, the X Window system (or 'X' for short) was the Unix answer to the windowing systems that were appearing on Macs, Amigas and DOS PCs. But X, coming from a Unix heritage, embodied an important part of the Unix philosophy; the machine on which the program ran might not necessarily be the same machine that it's being controlled from. So while a Windows program expects its menus and buttons and pictures to be displayed on the screen plugged into the computer it's running on, an equivalent X program could be running on a machine in New York but have its display seen and manipulated on a screen connected to a computer in San Francisco. To X, it doesn't matter. Both the program and its display could even be on the same machine - just like it is with Windows and OS/2's Presentation Manager.

It should be noted that X uses a funny reversal of the terms "client" and "server". Under typical circumstances, the program you're controlling might be on a machine that you call a "server", controlled from a desktop PC or terminal that you call a "client". But as far as X is concerned the PC/Terminal is running an "X server" (serving an X GUI to the program) and the server machine is running an "X client" (a program making use of the X server). It's daft to us, but that's the way its terminology goes.

Since X has its own API (Application Programming Interface), it's necessary to install an X Window server to run X Window applications and for OS/2 there are at least three or four that you can choose from. There's Exceed from Hummingbird communications, a commercial implementation that supports some extra frills such as seamless integration with the OS/2 desktop. PMX from IBM, sadly discontinued. And XFree, which as its name implies, is free software. XFree doesn't have as many frills as Exceed does, there's no seamless OS/2 desktop integration (so you have to run it fullscreen all the time), and no Clipboard sharing built into it. There's a program you can download that will attempt to run X on the OS/2 desktop, using DIVE, but we were unable to make it work. Plus there's another utility that will share OS/2's clipboard with the one in X, not quite fully though.

But despite XFree needing to run in a full-screen session, it's still possible to run it alongside your regular PM / Workplace Shell desktop, switching between the two with the window list and ALT-Escape. And despite all the rah-rah about X's networking support, you don't actually need -two- machines to use an X Window application. X will simply communicate with the program through a named pipe, or a -loopback- interface.

Installing XFree:

Even though Unix software has a reputation for being arcane, XFree for OS/2 is easy to install. The basic steps are to download a couple of base files, run a program that helps you identify your video card and what driver you should use, download that driver and whatever remaining optional files you want, then run a program that asks you a few questions and configures X Windows for you.

In more detail, the steps are as follows:

1: Download the base files:

From the (ftp://ftp.xfree86.org/pub/XFree86/3.3.3/binaries/OS2/) xfree86.org FTP site, in the directory for the OS/2 port, you need to grab emxrt.zip and xbase.zip, saving both of them to your C:\ directory (or the root directory of any other drive if you prefer) when your browser or FTP client asks where to put them. Skip the emxrt package if you've already installed a recent version of EMX.

Once downloaded, open an OS/2 Window (command line) and from that root directory unzip the packages, probably typing "unzip *.zip" if you have InfoZip installed, or "pkunzip *.zip -d" if you have PKZip. You need to make sure the directory structures will be unpacked as well, something that isn't usually a default option with PK Zip. You'll notice it'll be creating and unpacking to a directory called "Xfree86" and "emx".

Among the files it will have unpacked will be a device driver called xf86sup.sys. This adds some more functions that X needs and must be loaded from your CONFIG.SYS, so it's about this time we'll add that and a couple of other values that should be in there - reducing the number of reboots we need to only one before XFree can be run. Opening the config.sys into a text editor, add this somewhere at the bottom:

DEVICE=C:\XFree86\lib\xf86sup.sys

A few other lines that would be handy at this point are:

SET TERM=ansi

SET TERMCAP=C:/XFree86/lib/etc/emx.termcap.X11

SET HOME=C:\home

SET X11ROOT=C:

SET DISPLAY=localhost:0.0

SET USE_HOSTS_FIRST=1

You'll want to change the references to "C:" if you're installing this to another drive letter, of course. Lastly, make sure the following is in your LIBPATH:

C:\emx\dll;C:\XFREE86\LIB;

And that this is somewhere in your regular PATH:

C:\XFREE86\BIN;

The above lines add: A terminal emulation mode (ansi), a home directory (make sure you create this before you run X), the root drive of where XFree can find the "XFree86" directory, and the location of the display ("localhost", a shortcut that always points to -your- machine).

A note about Localhost, you should go into the TCP/IP Configuration notebook in your OS/2 System Setup folder and make sure it's enabled and pointing to the address 127.0.0.1 (the universal shortcut to your own machine). You'll find the settings on the first page in that notebook, under the item "loopback interface". It's through this that X will communicate with the programs you run under it. Without it, X won't work.

At about this point you'll need to reboot your computer, it'll be the only time you'll have to even though we'll be adding one more line to the CONFIG.SYS before it's all over.

2: Run Superprobe:

Superprobe.exe, now found in the XFree86\bin directory of your hard drive, is a simple video card detection program. -Most- of the time it will correctly identify what video card you have, and if not, you can probably identify the right driver to use just by knowing who made your card and what approximate model it is. Run this in a full-screen OS/2 session and make a note of what it reports.

Since XFree itself also runs in a full-screen session it must have its own video drivers, it can't use OS/2's Presentation Manager drivers and there are no "seamless" drivers for XFree that we were able to get working (there's an "early alpha" of one that purports to use DIVE, but we failed to make it work). That's an inconvenience, but not a terrible one since you can still switch back and forth between the Workplace Shell and XFree by using the window list or any other task switching utility you prefer.

3: Download the Driver:

Going back to the (ftp://ftp.xfree86.org/pub/XFree86/3.3.3/binaries/OS2/) XFree FTP site you'll need to download the driver that corresponds to your video card. XFree has an odd way of grouping its video card support, some cards such as ATI and S3 based cards will have their own separate drivers, while Matrox, generic SuperVGA and others will be all combined into one general-purpose SVGA driver. Don't worry if the documentation calls the "SVGA" driver an 8-bit, or 256 color driver only, it'll support true-color displays (16 bit and higher) if your card does too. It will also support all the extra "accelerated" video features of advanced cards like the Matrox Millenium.

A note about the naming convention that's used on the FTP site. There are actually two sets of drivers, one set that begins with an 'S', and another that begins with 'X'. the 'S' set are smaller drivers that have a number of extra support features taken out. The 'X' drivers are the full-featured ones, with extra libraries compiled into them, some of which may be used by the programs you'll want to run after you have X working. Choose the 'X' ones for now, since the difference isn't that big.

Like with all of the other XFree distribution files, download this driver to the root directory of the partition or hard drive you're installing X on. Unzip them there and the files will be unpacked into the correct directories.

While you're at the FTP site you should also grab a few of the other required and optional packages too. XBIN.ZIP (remaining binaries), XDOC.ZIP (documentation) and XFNTS.ZIP (75 dpi fonts) are all required, but also think about getting XFSCL.ZIP (scalable Speedo and Type1 fonts) and XMAN.ZIP (manual pages, for documentation) too.

4: Configure XFree:

With everything unzipped you should be able to find a program called xf86config.exe in the XFree86\bin directory. Run this and answer the questions it asks you about your system and preferences. *Pay attention*, especially the sections about video card "clock" chips. If, after you've picked your video card from its extensive list, it recommends NOT to probe for clock chips, it will still ask you if you want to do it anyway. Always go with the recommendation unless you think you have good reason not to. The philosophy that XFree is steeped in assumes that the user always knows what he/she is doing. So if you don't, just do exactly what it tells you ;-)

Other than just needing an alert operator, XF86config is easy enough to get through. It'll ask you what scan frequencies that your monitor can handle, so it's a good idea to check the monitor's manual beforehand to find out. If you've lost the manual, try something conservative (a narrow range that doesn't go above 90khz or so), and if it doesn't work you can always go back and run xf86config again. It's unlikely that you'll damage the monitor by trying to run it at a refresh rate higher than it can handle, but try to get as high as you can anyway. The higher the refresh rate, the easier it is on the eyes to stare at the screen.

The configuration file that it creates, called XF86Config, is a human-readable text file that you'll find in the Xfree86\lib\X11 directory. If you messed up somewhere and don't want to run the configuration program from scratch again, just load up this file in a text editor. It has enough comments embedded in it to help you understand its structure.

5: Run XFree:

At about this time it should be safe to run XFree for the first time. X is started with the script "startx.cmd" that you'll find in the XFree86\bin directory. Open an OS/2 Full Screen session (or window, it'll jump to full-screen mode anyway) and change to this directory. But before you start XFree you'll need to type one extra line, one that you'll end up migrating into the CONFIG.SYS eventually, but for now can be typed here so you don't need to reboot:

SET XSERVER=C:/XFree86/bin/XF86_SVGA.exe

Look at that line carefully. First of all, like with the "SET TERMCAP" of earlier, we're using -forward- slashes (the Unix style directory name separator) and the XF86_SVGA.exe is refering to the video driver we downloaded earlier. If you're not using the SVGA server, change this to the one you are using. Once you're satisfied that it's correct, you can move it into your CONFIG.SYS, probably grouping it with the other XFree related settings.

Next, type "startx", and if all goes well you'll be looking at a properly configured XFree a few seconds later. If not, try running the "checkinstall.cmd" program from a command line (found in your XFree85\bin directory too), as its name implies, it will check how your computer is set up and will offer some hints if something is missing or wrong.

Minor Configuration Details - Resolution:

There will remain a few issues of preference that you'll want to fix after X is installed and working. First of all, it'll start in some ridiculously small video mode by default, probably 640x480. To change this -on the fly- you hold down the CTRL and ALT keys, then hit the + or - key on the keyboard to cycle up or down through video modes. This is certainly handy if you want to zoom in on something, just press CTRL+ALT and the - (minus) key. But you'll probably want to change the settings so that X -always- starts in the video mode you want. This is how:

* Open the XF86Config file in the XFree86\lib\X11 directory with a text editor (like the OS/2 System Editor).
* Find the "Screen Sections", ignoring the "Monitor" and "Modeline" sections.
* Re-order the listing of screen resolutions in the various "Subsection Display" areas. There's a separate section for each -color depth-. So where the default line might look like this:

"640x480" "800x600" "1024x768" "1280x1024"

Your modified line could look like this:

"1280x1024" "1024x768" "800x600" "640x480"

Change these for each color depth level that you think you'll be working in.

Color Depth:

By default, X will usually always start in 256 color mode too, which will be annoying if you like to do graphics editing work or dislike the dithering effects that will be applied at that depth. To bump it up to higher color depths (to the extent that your video card supports) you need to run the "startx" program with a command line switch that looks a bit like this:

startx -- -bpp 16

Notice the two dashes followed by a space and then another dash before the "bpp" part (which stands for "bits per pixel"). 256 color mode is 8 bits per pixel, 65 thousand color mode is 16 bits per pixel, and 16 million color mode is 24 bits per pixel. Be advised that the higher the color depth (bits per pixel), the more memory is used for any given resolution. A video card with only 2 megs of ram couldn't achieve more than 1024x768 in a 16 bit color depth, for example. A card with 4 megs of video ram should get up to 1280x1024 in 24 bit depth and higher.

The Window Manager:

One other concept that X introduces is that of the Window Manager, a program which controls how everything appears -outside- each program's window. That is, it determines not only how the window frames and control buttons (close, minimize etc) look and behave, but it may also provide a mechanism for launching new programs and task switching them. Interesting is the fact that you can choose whatever Window Manager you like without disturbing the programs running, so you can switch between Window Managers without restarting.

The window manager that will run by default when you start up XFree86 for OS/2, TWM, is awful and ought to be replaced fast. Fortunately, while TWM is the default, XFree86 for OS/2 also comes with a better window manager called IceWM. This one mimics the OS/2 look and feel to some degree. No window manager yet matches the flexibility of the Workplace Shell.

To change the default TWM manager to IceWM you need to use a text editor to open the xinitrc.cmd file that you'll find in the Xfree86\lib\X11\xinit directory. Scroll down until you get almost to the very end, you'll see a line that looks like this:

'twm'

Delete that, and in its place put:

'icewm'

When you restart X you'll have the new window manager. Sometimes it's possible to exit out of the window manager without exiting all the way out of X. If so, and you have an Xterm (X equivalent of a command line window, XFree will run the standard OS/2 command interpreter within one of these) open, you can launch another window manager next. You can't run two window managers at the same time, however.

Dvorak Keyboard Layouts:

If you prefer to use the Dvorak keyboard layout (an alternative to QWERTY where the vowels are all on the home row and other keys are arranged to help speed up typing) you can add it to XFree very easily. Remember the HOME directory you set in the CONFIG.SYS earlier? Among other configuration files that various X (and even some Java and native OS/2) programs will put there, you can add some of your own. ".Xmodmap" (notice period at the -beginning- of the filename) is one that, when detected by the X startup program, will be used to reconfigure the X Windows keyboard layout. We chose to make our own Dvorak layout file (http://www.os2ezine.com/v4n4/.Xmodmap) that you can download to use yourself, but you may also find others available elsewhere on the net. After creating (or copying) this file in the HOME directory (usually something like C:\Home or C:\Home\YourName in OS/2, you'll have to create it yourself), the new layout will always take effect whenever you start X.

Multiple Users:

Incidentally, it's about here that we could mention the multi-user nature of X and Unix. That HOME directory is needed because it's created as a matter of course on Unix systems. Every user on a computer will have his or her own home directory, and it's here that preference files are kept. While one user types QWERTY, another likes Dvorak, and if the keyboard layout file is stored in the home directory rather than some global one then it's easier to keep those preferences separate. Each user, with access to only his or her home directory, can edit these files without fear of stomping over anyone else's preferences.

So why mention this in an article about the OS/2 version? OS/2 Warp was designed with the assumption that there'd be only one user per machine (Workspace on Demand is the true multi-user version of OS/2). But remember that this HOME directory was provided with a SET command, a command that can be issued on the command line, without rebooting, and does not necessarily need to be in the CONFIG.SYS. So if you have more than one person using your computer it'd be possible to create a small batch file that overrides the default HOME and lists another one instead, establishing a -psydo- multi-user system. You could create a hierarchy of directories that look like this:

C:\Home\Chris
C:\Home\Dirk
C:\Home\Trevor

And create icons that change the HOME environment variable before starting X. Each user then has his or her own place to store their preferences, just like on a Unix system.

Launching and Switching Programs:

And lastly, the method of launching and switching programs in X is going to differ from window manager to window manager, but the universal method of -launching- that will always work is to just type its name into an Xterm window. By default, XFree will launch at least one Xterm window, usually called "login" (the name is essentially meaningless on a single-user OS/2 machine, but that's the only difference between it and any other Xterm window that you might open). Since it's passing all of those commands through the standard CMD.EXE (OS/2 command processor) you can use any command line instruction that you're familiar with.

***********************************

Installing GIMP/2  - Chris Wenham

Summary: If the OS/2 graphics market is a snooze, wake it up with GIMP - the impressive photo manipulation tool for Unix that's been ported to OS/2.

There's some good news and some bad news. The good news is that GIMP, a spectacular graphics tool with anti-aliasing support, layers, channels, and about as many plugin effects as there are pizzas in Chicago, has been ported to OS/2. The bad news is that you still need an X Window server to run it, and that's partially why we have the XFree86/2 installation tutorial in this issue too.

But GIMP, to be frank, is worth the bother. We think you'll easily see why.

What Is GIMP?:

Short for GNU Image Manipulation Program, The GIMP can be a painting tool or an image manipulation tool. The difference being that when you -paint- you're      creating a picture from scratch, and when you -manipulate- you're changing an existing picture.

The GIMP project was started in response to Photoshop's proprietary (and expensive) nature and as such, GIMP is free and open. Recently, programmers working together through The OS/2 Netlabs have ported it to OS/2 with the help of EMX and XFree. The use of XFree made the job much easier, of course, since they didn't have to port it to a whole new API, but it also means you won't be able to share its clipboard with any other OS/2 graphics program, nor will you be able to run it seamlessly on the OS/2 desktop unless you use a different X server such as Exceed (any X Windows program should work with any X server, even if one is running on a different operating system).

Installing GIMP:

There are a number of sites where GIMP/2 has been mirrored for easier downloading. The primary site is the (ftp://ftp.netlabs.org/pub/graphic/gimp_10x/) OS/2 Netlabs server in Switzerland, but if you're in the United States you might have better luck getting it from (http://hobbes.nmsu.edu/cgi-bin/h-browse?sh=1&dir=/pub/os2/apps/graphics/gimp&sort=date) Hobbes. What you'll want is the latest version, 1.0.2 as of the time we write this article. These are the files you'll want to grab:

gimp102bin.zip (the main program files)
gimp10data.zip (the data files)
gimp10dataex.zip (extra, but optional data files such as brush shapes and textures)

Gimp is easier to install than XFree, although we think they were packaged in a dumb way. You just save these zip files to the root directory of the drive where you installed XFree and unzip them. They'll expand to complete directories within the XFree86 hierarchy, which is all well and good if Xfree86 is your X Server, but not fabulous if you use Exceed or PMX instead.

There's no formal install program other than GIMP itself, which will tell if you're running it for the first time. It should be noted that it considers "first time" to mean first time for a -user-, not the first time run on that particular machine. If you run a multi-user OS/2 system where the HOME directory is different for each person using the computer, then GIMP will re set itself up for that user the first time they run the program. This is a good thing, since it only stores its preferences plus any custom brushes and textures in each HOME directory, not the whole program.

After all the zip files have been extracted properly, just type "gimp" from an Xterm window within XFree or whichever X Server you have, navigating to the XFree86\bin directory first if necessary. GIMP can run in 256 color depth modes, but is much nicer if you start X with the "-- -bpp 16" option (or "-- -bpp 24" if your video card allows it) to jump into true-color modes.

Using GIMP:

GIMP acts like most typical paint programs. While we won't go into much detail now, we will discuss a little about navigating around the program to get what you want. GIMP doesn't start up by allocating a big container window like Embellish or ColorWorks does, it just throws down a palette of tools on an otherwise empty desktop. Helpfully enough it will also display a brief usage tip.

To get started you might begin by creating a new file or opening an existing one. GIMP comes with enough filters to read everything but Klingon, so we doubt you'll have any problems importing what you've already got. When you have a canvas window open, try right clicking on it with the mouse. That's where the rest of the goodies are. In particular, go down to the "Dialogs" menu and start opening palettes such as the Layers palette (imagine your composition made up of sheets of acetate; each layer is separately editable but can be combined to view the whole image), or the Gradient Editor - a tool that compares with some of the earlier Kai's Power Tools gradient editors and honestly beats the pants off anything available for fully native OS/2.

Drawing Shapes:

Some other basics to get acquainted with are the shape drawing tools (rectangles and circles). Like Photoshop, GIMP covers these basics by having you use the rectangular or circular -selection- tools, or the tools that select an area on the canvas and confine painting to that area. Select a circular area and click in it with the bucket fill tool and you'll create a filled circle or ellipse. Same goes for Rectangles. But if you need to make hollow shapes, you use the Brushes dialog to select which brush you use, then after drawing your shape with the selection tool pick *Edit* -> *Stroke* from the right-click menu. This command will paint the -edges- of the current selection (which could also be a freehand or "magic wand" selection) with the current brush. If the selection is circular, it'll paint a ring. Easy to do, even if it's a few more clicks than a regular "hollow circle" or "hollow rectangle" tool, such as what Embellish gives you.

For tutorials, more tips, and the whopping 19 megabyte PDF user manual, visit the (http://www.gimp.org/) official GIMP web site.

Scripts and Plugins:

GIMP has benefited from a community of programmers clustering around its open source model, many of whom choose to add features through GIMP's scripting language: Script-Fu. As an interpreted language, you won't need a compiler to write plugins with it, and if you're completely lazy you'll be glad to find that almost all glossy gee-whiz graphical effects such as chromed lettering have already been implemented. Without opening any canvas windows, you can go to the "Xtras" menu in the GIMP toolbar and start playing with a few of the "Instant Logo" scripts it has listed there. Most of them will present a dialog box where you can type the text you want to render, pick the font (watch this part, most of the scripts default to a font that isn't installed with XFree), and usually also the colors or textures.

Plugins are also copiously abundant, these being compiled mini-programs rather than scripts. Already the vast majority of them have been ported to OS/2 for use with GIMP. Like with GIMP itself, these will be packaged with their directory structures intact, so you'll be unzipping them from the root directory of the drive that you installed XFree or GIMP to. Most of the plugins ported so far already come with GIMP/2, but some extras like the lighting effects plugin and the Gimpress plugin are distributed separately.

Some other plugins of interest are the Graphics Muse Tools and GIMP Dynamic Text.

Better News to Come:

The better news to come is that the people who have ported GIMP to OS/2 for use under an X Window server are working on creating a Presentation Manager version, which will mean you'll no longer need X. We don't know how soon this will come.

***********************************

Why OpenSource?  - Ulrich Moeller

Summary: The author of the popular XFolder enhancement utility speaks out on what his reasons were for switching to an Open Source model, and makes a plea for other freeware developers to do the same.

Back in September of 1998, (http://www2.rz.hu-berlin.de/~h0444vnd/os2.htm) XFolder V0.80 was released. As opposed to previous versions, that version was placed under the GNU General Public License (GPL), which implied that the source code was released. All other software I have written since then has also been placed under the GPL: this includes INF2HTML and the WarpIN alpha versions which have been released so far.

If you are a user of my software, you might already have wondered what the GPL does for OS/2 and why I now stress the licensing issue so much with my own software. Well, there has been quite some debate in the OS/2 world about licensing models recently. I won't go into all of this here; read Chris Wright's articles in (http://www.os2ezine.com/v4n1/) OS/2 e-Zine! vol. 4 no. 1 for more details.

But as a summary, the GPL is a general license agreement which was developed by the Free Software Foundation to protect the rights of programmers who wish to publish the source code of their software. The GPL is most frequently used with software of the GNU project and has become more widely known with the evolution of Linux, to most parts of which the GPL applies.

Software which has been placed under the GPL is frequently called OpenSource software. While there are other licenses which can also be called OpenSource, the GPL is the most popular one. (As a side note: The term "OpenSource" is now a registered trademark to prevent misuse of it. That's why I think this term is now preferred over "Free Software". Check (http://www.opensource.org/) http://www.opensource.org for details.)

In this article, I'd like add my personal view on licensing issues and explain why I now think that OpenSource is the software model which might turn out to be a main condition for OS/2 to survive at all (as a non-server OS, that is).

As a consequence I'd like to convince all OS/2 freeware developers to release their source codes, preferably as OpenSource. But I'm not preaching to commercial developers here; there's a lot of shareware out there which is really worth the money and I do not envy developers who do earn money through it. Out of the many, just think of PMMail and PMView, which are among the best on -any- platform.

However, there are a lot of freeware programmers out there who have so far not released their sources. I will not list them, you know who you are. It is you that I'd like to address with this article.

Why I Released My Sources:

In my view, there are two main models of distributing software. Many people will draw the line between software you have to pay for and software you don't. That's what I used to think, too.

The real distinction however, and this is important for OS/2's future, is between software which is shipped with the source code and software which is not.

The problem with OS/2 however is that releasing source code seems like some kind of threat to developers, who feel a lot like Windows programmers in this respect. Source code is something they feel they "own" and that they'd prefer to keep private. It's a bit like letting people look into your diary.

Before releasing XFolder's source code (that is, before V0.80), I had the same feeling. I spent three weeks reflecting on whether to release the sources, and I considered the pros and cons.

Back then, the key reason for me to publish the source code was that XFolder has become a fairly complex application by now, and it had become increasingly difficult to find bugs, because many of these simply do not show up with my system configuration, and I am not willing to buy new hardware just to debug XFolder. I hoped that with the sources some users would be able to find bugs in the code themselves.

The reason for choosing the GPL for the license was that it's nicely complex, and this appealed to me as a soon-to-be lawyer. But seriously, the main reason was that it seemed to give my sources a bit of protection against "code theft"; I didn't want anyone to just take my work of a whole year, which I had always released as freeware, and make money out of it. I don't mind people earning money; I just thought they should earn it for their own work.

Why OpenSource Will Help OS/2 In General:

My focus has changed since then. I have done a lot more reading on OpenSource software, am following some of the discussions in the Linux world, and by now I have almost half a year of experience with this concept from a developer's perspective. From my perception, there are many more advantages to the OpenSource concept which should convince any freeware programmer to release his/her sources.

The most pressing problem with OS/2 is that there aren't as many home users left as used to be in the "golden days" when Warp 3 came out and IBM did indeed care about the home user market. Most people would agree that this situation won't ever come back again, and this is the reason why many software developers (especially commercial ones) are moving away from OS/2, either to Windows or to Linux, whatever preference they have.

So the key question is this (and this question is not for developers only; OS/2 and OS/2 users need software, and this has to be written): How do we get *more and better software* even though OS/2's reputation has reached an all-time low and we have *less programmers than before?*

In my view, there are three conclusions to be drawn from the current situation.

* For one, *OS/2 software development needs to be done more economically.* OS/2 developers tend to re-invent the wheel hundreds of times, because they have to.

But as Eric S. Raymond puts it ("The Cathedral and the Bazaar", (http://www.tuxedo.org/~esr/writings/cathedral-bazaar) http://www.tuxedo.org/~esr/writings/cathedral-bazaar): -"Good programmers know what to write. Great ones know what to rewrite (and reuse)."- OpenSource allows for code re-use, so this is may be the most obvious advantage of it.

There's already one example in XFolder where OpenSource has actually helped in this way, and maybe also one of the most popular features, too. It's the APM power-off after system shutdown, and since my computer does not support this feature I could not implement it myself. So what I did was insert some dumb stub code which gets called by the new XFolder shutdown routines, then hoped that someday, somebody would make these dumb functions intelligent. Atsushi Arakawa rose to the challenge and filled this in with the code from APM/2 by Roman Stangl. He could only do so because the sources of both XFolder and APM/2 were publicly available. *So if these sources had not been released, this XFolder feature wouldn't exist.*

By contrast, there are many programs out there which have been released as "freeware", that is, you don't have to pay, but the sources are not available. With many of these freeware projects you'll find that, one day, its developer has had reason to stop further development of that software (this might be lack of time, other interests, business, or whatever), leaving the program pretty much dead as no-one can enhance it any longer.

A good example of this is NPSWPS, still one of the most widely used OS/2 utilities but which has not changed for years. In order to add just a single feature to it, someone would have to rewrite the whole thing. It just doesn't make sense to rewrite everything that someone has done before, and since anyone who has ever written a PM hook knows what a heck of a job NPSWPS really is, we have the deadlock situation that this piece of software will probably always remain as it is now. *This is a situation the OS/2 community can no longer afford.*

With OpenSource software, this is radically different. OpenSource means that not only are the sources available, but people may build on that and create "work based on the Program", as the GPL calls it. If NPSWPS had been OpenSource, someone by now would have started working on new versions, because he or she wouldn't have to re-invent the wheel and we'd have a better version with more features, which we don't have now. We could already have much more OS/2 software if people (including me) had come up with this earlier and other developers could have built upon existing sources.

Believe it or not, even Microsoft has realized this (from the infamous "Halloween documents", (http://www.opensource.org/halloween1.html) "http://www.opensource.org/halloween1.html"): -"The likelihood that Apache- [which is OpenSource, U.M.] -will cease to exist is orders of magnitudes lower than the likelihood that WordPerfect, for example, will disappear. The disappearance of Apache is not tied to the disappearance of binaries (which are affected by purchasing shifts, etc.) but rather to the disappearance of source code and the knowledge base."-

This is why OpenSource is now considered a serious threat to Microsoft's revenues by themselves. Even if you don't hold Microsoft to be the new Antichrist, you probably do care for more and better software.

And this is also why Netscape have chosen to release Mozilla as OpenSource. They explicitly referred to the arguments given by Eric S. Raymond when they did so. And most of the really promising OS/2 projects at the moment depend on OpenSource: just think of GIMP/2 (and XFree/2 in the first place), WarpZilla, Win32-OS/2 (whose developers are now going for the WINE sources), the ShapeWindows library, and many more.

Let's extend that code pool, because many important aspects of OS/2 programming are still missing.

* Since many commercial and non-commercial developers have turned away from OS/2, *we need new OS/2 programmers.*

This might sound awkward at first: how can we get new programmers if everyone is going away? But from the mail I'm getting, I gather that there are many users out there who would -like- to write new software, but don't know how to. I've gotten dozens of mails like, -"I'd really like to help you, and I think it's great that you released the sources, but PM programming just gets me."-

It was only in 1997 that I started writing software in C, and I do remember very well this situation. The learning curve for writing OS/2 programs is just extremely high, especially when you're going for Presentation Manager or WPS programming (in this order). Once you get into it, it's pure beauty, but getting started is a hassle.

The existing documentation for OS/2 development can broadly be separated into two groups: for one, there's reference information     (mostly by IBM, and partly incomplete and incorrect), and then there's articles about certain individual aspects of programming. The latter applies, for example, to (http://www.edm2.com/) EDM/2, which is undoubtedly the very best programming source for OS/2, but mostly too complicated for beginners.

The problem is that there is only very little -working- source code out there. Something a new developer could build upon or take parts out of in order not to have to learn the whole thing.

OpenSource can help this too because then new programmers can learn from what others have done. They won't have to go through the same mistakes again, like I had to. *OpenSource will allow those who are interested to start programming more easily.*

* Maybe you ask, why OpenSource and not just the sources? Well, the inherent logic of OpenSource is that software based on other OpenSource software needs to be OpenSource too. This is most obvious with the GPL: if you create a "work based on the Program", the GPL between you and the program's creator(s) requires you to place your software under the GPL too. People cannot take the code and make it "closed". As soon as something is added, its sources have to be released. *As a result, the amount of available source code always increases.*

It is only this concept which has made Linux so strong. Nobody can take the Linux kernel and make a closed, commercial version out of it without releasing the source code. This has a lot of advantages: as opposed to earlier UNIX derivatives, Linux has never been "forked", i.e. separated into several incompatible versions, and the number and complexity of Linux applications is growing at a rate which has never been observed on any operating system.

Also, and maybe most important, as Microsoft puts it (again, from the "Halloween Documents"): -"Linux and other OSS (Open Source Software] advocates are making a progressively more credible argument that OSS software is at least as robust -- if not more -- than commercial alternatives. The Internet provides an ideal, high-visibility showcase for the OSS world."-

In other words: *OpenSource software is more stable.* That's because if you release the sources, people can find bugs themselves. And it's better that a programmer somewhere finds a bug before it will ruin someone's enterprise. Very simple.

Objections?:

I have been talking about this to a number of developers recently. Many times I hear, -"Well, I do appreciate the OpenSource idea, but my sources are just too ugly to be released. I haven't commented anything."-

This is the "diary objection." I admit that I had the same feeling with XFolder V0.80. See, I only started C and PM/WPS programming with XFolder; before that, I used Borland Pascal 7.0 for DOS/Windows and REXX only. Last year, I feared too that some C++-SOM-OO-WPS-Smalltalk guru would come up and laugh at me.

But believe me, this won't happen.

Obviously, clean, commented sources are better than ugly, uncommented ones. But then: *ugly, uncommented sources are better than no sources at all.* And maybe someone will take a look at your code and try to understand what's going on by commenting out things. That's what I have done with some of the sources I found on the Net and which are now part of XFolder.

Besides, if you look at the sources of XFolder V0.80 and compare it to the current ones (V0.84 at the time of writing), you'll see that I've cleaned up a lot of things during the last half year. Lots more comments have been added, and the structure of the code has been straightened out a great deal, mostly because the code has been split into many more files to make its function more lucid. What I'm trying to say is that *the publicity of your source code is also a   motivation to clean things up.* In this process, I have found quite a number of bugs and memory leaks in XFolder, which maybe I wouldn't have found without this motivation. Trying to re-understand your own code sometimes does help.

Summary:

To finalize this, I do think that the only chance for OS/2 to survive is that at least the freeware developers who are writing software today must switch to using an OpenSource license, no matter how ugly the sources are.

It is worth it, even if only one person finds a bug in your code. And even if this doesn't happen, maybe one year from now there'll be someone who will use your code to build something even better. Better still, some novice developer might find a reason to start programming.

And even if you don't like the OpenSource idea (despite the arguments I have listed above), please seek a way to publish your source code anyway, under a different license if need be.

Let's release sources now before it's too late.

***********************************

Making Money with OS/2  - Bob St. John

Summary: The little secret that IBM just might want to keep secret. How a simple consultant can sell OS/2 as a service rather than a product and bypass the whole "OS/2 or Windows?" question entirely.

I need to make clear that this point off view is not appropriate for everyone. It is most appropriate for consultants doing fee services and would be appropriate for commercially oriented ISVs, but it may be of interest to others. With my background in OS/2 brand management for IBM, and as a general advocate for OS/2, I've toyed with the "if I must play the hand I'm dealt; if I must work with circumstances as they exist, can I be successful with OS/2?" scenario. I think the answer can be "Yes". Let me make this the first salvo in what should be a lively discussion.

First, I need a business solution because you need to be solving a business problem. In our environment, we call those applications. For my example I will use Aviar's "Oz" application, but many OS/2, DOS, and Windows apps would work as well. If you are not familiar with Oz (the abbreviation for ounce), go to (http://www.oops-web.com/) their web site. Oz is the OS/2 follow-on version to the DOS Ounce of Prevention Software (OOPS). These two applications are "computerized maintenance management systems" or CMMS. Applications which allow an organization to list tasks which must be performed, schedule the tasks, track costs, labor, inventories of parts, trigger purchasing requests, generate work orders, check compliance with regard to inspections, document required maintenance checks, record actions taken, create schedules. In short, a very handy application for an organization which has to track and document the execution of many tasks, including maintaining their facilities.

John Urbaniak, president of Aviar, can tell you that his sales suffer because this application runs on OS/2. Each sale of Oz involves OS/2 and UDB. So, how do we get an organization to use and OS/2 application if they don't want to use OS/2? My answer is: don't sell the product. Don't force them to say "Yes" to a "Do you want to buy OS/2?" decision. Position the application as a turnkey service; all software, hardware, and support becomes part of the contracted service.

When you talk about an application, the first thing users are likely to ask is "What does it run on?" In terms of both hardware and software, they are thinking of cost and skills to support it, how it fits in to their infrastructure. Being known as an OS/2, WindowsNT, or Java application may actually become more of a factor than the feature set or price of the application itself. How can an organization with no OS/2 skills consider buying an OS/2 application? But when you discuss a service with a user, the focus is on what the service does, the feature set and how that relates to the cost of the service.

This avoids lighting several fuses. First and foremost, you side step the emotional OS/2 decision. Who has the time to persuade everyone who thinks they "need" Windows that they are wrong? And the entire sale becomes an operational expense, not a capital expenditure. In many organizations, retaining a service is a much easier process to complete than to actually acquire - to -purchase- - an asset.

Now, I'm going to bring in my "fee services consultant", whom I will call Fred. Fred makes a living installing TCP/IP networks for people, doing general technical support, taking on some contracts for computer and network activities. It's a good life. But Fred's excellent OS/2 skills are not providing the return on the investment he made developing those skills. This is not always true, but more and more folks are asking Fred to do things with other products and platforms. Fred spent time and money becoming an OS/2 Warp Server guy. He's good at it. He likes it. Fred can do great things with it. But it just isn't happening very much anymore.

Fred knows he can take OS/2, client and server, and build a bulletproof network that's simply a never-go-down, seven-days-a-week, 24-hours-a-day environment. He's got options to meet requirements. He can do mirroring, backup server failover (VINCA), there's lots he can do in the design to make this thing an industrial strength, bet your business, mission critical network. And now Fred is beginning to see a way to make this pay off for him.

The PC client is simply an application platform, a line of business applications, communications and messaging tool. With OS/2, Fred can build a superior network to deliver the application to the user. Now Aviar has provided him with a superior application. Fred's off to visit prospects in his territory, blue collar outfits with a large maintenance or "physical plant" department. He is going to present Oz to them as fully supported service from Fred's IT Services company. All the hardware, software, instruction, support, and so forth are part of Fred's complete CMMS service.

What is the user "buying"? Well, first there is access to the excellent function of the CMMS package. But past that the user is buying the ability to retain a service; to "outsource" if you will, all the computer and IT related issues. No user operations or user administration and support. No network management. No software deployment or concerns about obsolescence, upgrades, or product life. I can rattle off all the tasks associated with "total cost of ownership", but the key message is that the user is buying peace of mind. Yes, it's function, reliability, availability, simplicity, but also peace of mind because Fred going to take care of it all. And Fred can do this for less money than the user organization can because this is Fred's business. He is a specialist.

This reduces OS/2 to an embedded operating system running in an appliance. That appliance just happens to be the CMMS workstation. You know it's a PC. I know it's a PC. But I'm talking about marketing positioning. OS/2 is no longer an issue to the user. Fred sets this up for them, customizes the application and the workstation, then trains them. All fee services for Fred.

As to the CMMS application itself, Fred can charge a monthly fee per workstation, thus setting up a recurring revenue stream for himself. There could be a base service fee per month, augmented by the number of "seats". He can break it down by access to the application, support, and other features. It's an open book without any rules. In fact, Fred can develop multiple pricing plans as part of one proposal to a prospect. Let them spend energies figuring out which is the best deal for them. An old marketing ploy!

Fred will also be slanting this so he gets other opportunities. For example, with Managed Clients from Serenity Systems, the WiseManager, DominoGo, APACHE, Hethmon Brothers Mail Server, and the clients have PMMail, RelishNet, FaxWorks, and Netscape Communicator. Fred can create a functional intranet with complete e-mail capabilities and internal web sites. But think of all the buzz words he can deliver to the user as additional services to the CMMS function.

Fred sets up the network, the CMMS workstations, maybe he gets a couple of other clients out of it because of the intranet angle. He has a monthly service agreement with a minimum 6 month commitment, cancellation penalties, and lower rates for extended agreements. His costs are pretty much covered and he got some fee service dollars for setup, training and customization. Just how well will he do?

In the beginning, his beeper may go off constantly as users get familiar with the system. But, after awhile, the "beeps" will become few and far between. And that's the sweet part. Once the shakedown period is over we all know this will run like a rock. He's services are not required on a day-to-day basis. And he can dial in to the server to do user and application management, even problem resolution using a product like NetOp. All he needs is his beeper, cell phone, and lap top computer. He is taking advantage of what Warp Server does best. Run all day and all night, without interruption.

Those pesky details:

For the sake of discussion, I oversimplified my example. But not very much. It's based in reality although I admit it hasn't been done, yet. Oz exists and can run on OS/2, including diskless RIPL, and WorkSpace on Demand. (http://www.serenity-systems.com/) Serenity Systems, working with its development partner, (http://www.deltanet.com/touchvoice/) TouchVoice, can provide all the hardware and software necessary, including IBM Netfinity Servers with OS/2 Warp Server SMP pre-loaded. Serenity Systems also provides diskless RIPL client PCs. With no moving parts, these machines are extremely reliable.

And spares or replacement client systems can be kept around. With WiseManager, featured in the current issue of (http://www.os2voice.org/VNL/past_issues/VNL0299H/vnewsf4.htm) VOICE, workstations can be set up in minutes. This may be one of the few reasons Fred would actually have to go to his customer's site. But try this: Fred leaves some spare workstations on the site. They aren't very valuable except as CMMS workstations because they don't have hard drives, diskette or CD ROM devices. On the box, Fred writes the "network id" of the built in ethernet card.

Now a client system fails and Fred gets beeped. Fred says, "Go to the shed, pull out a client box and read me the number on the side". He notes the number, dials into the server, and using WiseManager he changes the workstation definition to include the new NIC id the user read to him over the phone. And it boots! No changes to applications or user information is required. It can be that simple to recover from a catastrophic event.

Simply put, there are not many reasons for Fred to visit the site. New applications can be added. So can upgrades or modifications. Changes in users' desktop design, access to data or different sets of applications, creations of new users. All can be done remotely. Only OS/2 permits this kind of technical elegance, simplicity, and most important, the reliability to make this possible. This network was designed for availability and the function designed into it means that there will be few reasons for Fred to take active steps to manage the site and certainly, as noted, few reasons which would require his presence at the site. But his "royalty" checks come in every month. Sort of like the old IBM "time sharing" model. Customer didn't own the equipment, sometimes they owned the application. But generally they were paying for access. IBM did ok with that model.

Imagine getting beeped at midnight, turning to the lap top on the night table, dialing into the server and resetting some icons, then using FaxWorks to send a $300 invoice to the user for an off-peak emergency support incident. Then rolling over and going back to sleep. Leave the midnight runs to those supporting other products. I'm not suggesting gouging a customer. But when a call to a help desk costs $150, being able to provide the kind of service that puts a user back in business in just moments, any time of the day or night, has value. Fred deserves compensation for being smart enough not to give up on OS/2.

For Verticals, this may work, but what about the "Horizontal Market," the general business user?

Agreed, vertical applications make it simple because they are easy to replicate and tend to be the principal, if not the only application on the workstation. But general business users are also an excellent opportunity. The "casual business user" is about 80% of total business computer users. These casual users don't know much about their PC. I call them "application literate" as opposed to "PC literate". And that 80% are difficult, and therefore expensive, to support. They require an inordinate amount of the support resource in the traditional fat client PC model because they can't resolve their own problems.

Casual users also tend to disrupt the work environment by invoking the generally unproductive function I will call "peer support". In other words, they interrupt and bug their co-workers trying to find someone who can help them out. Now there are two people who are not working, more if others are "looking on". It calls to mind the axiom "You can't make something fool proof because fools are so clever". Fortunately for Fred, those 80% are excellent candidates for "managed client" systems. Fred is just the guy to manage those users as part of a complete desktop services contract.

Fred can go to accounts and tell them "You don't really want to own your IT. It costs you too much to support it and you will never have the in-house technical resource to do the job right. And any resource you expend on IT is resource taken away from servicing customers. When you get down to it, which supplies more revenue to you; managing your IT or servicing your customers?"

Part of what makes this scenario so attractive to user organizations is that they are worn out by the churn of technology upgrades. (Thank you for that, Microsoft) They would like to get off that treadmill and go back to the core business activities. That's part of what has made outsourcing so popular today.

What makes all this work is OS/2's ability to perform so reliably in a diskless RIPL environment. It is just not possible to do this with any other Intel OS today. And OS/2 is reasonably priced for this model.

But wait! What about the applications?:

The chances are that most applications run by small and medium sized accounts can run without modification under OS/2. This is because so many of these apps are DOS or supported by OS/2's subset of Win32. This protects the investment made in application software, which may not have been significant, but it also protects the investment users have made in training.

The show stopper until now has been Microsoft Office. But StarOffice has come along to provide the ability to exchange documents with those users. Smart Suite Millenium is good for this, too. But StarOffice is snappy in a network and I'm suggesting diskless RIPL clients. Smart Suite is really a fat client PC product not well suited to this environment.

And lets not forget, there are still many, many excellent OS/2 applications available. Products which are superior to Windows counterparts, more functional and more reliable. In line with this, OS/2 provides a world class Java Virtual Machine. So, while it's true that applications can be an issue, it can be addressed many times. Not all, but often.

And there is a trade off. The desktop management service provides the user organization with simplicity, cost savings, a computing environment which is more reliable and available to service customers using less in-house resources. Does the user organization want to do business, focusing on revenue steams and business objectives, or do they want to use MS Office? How does that help them? This is a better argument to make as a service than as a purchase decision.

If there are requirements for other PCs, likely to be running Windows, Fred can add their management to the same contract as with the Managed Clients, connecting them on the same Warp Server. It simply means that Fred will support those Windows users with the traditional model. This won't be as efficient as the Managed Clients but maybe he can convert some more of those Windows workstations at this account later.

And what's good for the goose ...:

I have focused on a consultant working with small to medium sized accounts because there are so many of them and there is a significant opportunity for many members of the OS/2 community to participate in this model. But the fact is this model works in many larger accounts as well. Client management is a challenge in any computer environment and this model goes a long way to addressing many key areas of client management. However, large organizations may have a significant IT investment to protect in products and skills. So, expect a different set of issues here.

If there is a significant number of existing OS/2 workstations, WiseManager and Managed Clients should be positioned as a management solution. In a Windows dominant environment, try focusing on the casual users. The IT organization would probably be delighted to "outsource" support for those. The casual user is the most difficult for IT to support on fat clients, but the easiest for Fred to support on Managed Clients.

Remember, Warp Server ... the same server supporting these managed clients, can also support Windows and Apple clients, as well as Novell, NT and *IX servers. So, managed clients can go where they are a good fit, all part of the same, happy network. And IBM recently demonstrated a Win32 WorkSpace on Demand client. This means some of those Windows machines may be able to participate in this model later this year.

Plus, is the Windows story so very pretty this year? Folks moving to Windows in 1999 and 2000 have a very real *dollar exposure* and the entire industry points this out in a different set of articles every week. Why not go to the safety of a Managed Client until Windows sorts itself out? Fred might even imply that his Managed Client is delivering on the Zero Administration for Windows promise. It will make the eventual migration to Windows more easily managed. But the reality is that once a Managed Client is in, working, and well supported, you may be hard put to find users ready to go to a less responsive, less reliable, and more expensive model.

I would add one more "positioning" remark. I have used the term Fat Client to refer to traditional PCs. That being PCs which function as PCs without a network connect, but may be connected for file and print, messaging, and so forth. I have used the term Managed Client to refer to the OS/2 diskless RIPL client, in this case using WiseManager and WiseClient. I have stayed away from "thin client". The industry tends define thin clients as computers which execute programs in the server, like Windows Terminals and Citrix WinFrame. This is not how Managed Clients operate.

Once these machines boot, they are much more like traditional PCs and NCs. Managed Clients are robust PCs running OS/2 Warp 4, not a selected subset. This is one of the reasons this model is so much more cost effective than NCs, Windows Terminals, traditional PC networks, even WorkSpace on Demand. The Managed Client, the complete desktop service that I described here, utilizes the best characteristics of each computing model. Fred can look his prospect in the eye, unflinching, and describe it as "the best of the rest". How's that for marketing weasel words?

Fred closes with, "We'll be setting up a complete computing environment for your use, directed at supporting your business objectives. Familiar applications and your current databases will be preserved. But you'll never have to buy another piece of software or hardware again if that's the way you want to go. When would you like to get out of the business of managing PCs? And, more to the point, how fast to you want to get back to servicing customers?"

And no small part of the Y2K angst should be ignored because OS/2 is Y2K ready. IBM is not mincing words on that score. But the verdict is still out on when Windows well get there.

***********************************

Rexx Newbies, Part V  - Chris Wenham

Summary: Functions let you take advantage of pre-written code that you don't have to understand the workings of. Nifty stuff, but first we'll show how to make a simple one of your own.

_Functions_

*Catch-Up:* If the instructions in this column make no sense to you then perhaps you need to freshen up on Rexx. Catch-up by reading these columns first:

* (http://www.os2ezine.com/v3n15/rxnew.htm) Part I
* (http://www.os2ezine.com/v3n16/rxnew.htm) Part II
* (http://www.os2ezine.com/v3n17/rxnew.htm) Part III
* (http://www.os2ezine.com/v3n18/rxnew.htm) Part IV



A television set gives us a good example when we want to describe what a -function- is and does. With a TV, you supply it with data (the signal from the antenna), parameters to manipulate that data with (which channel and volume you want), and the TV returns its results (a picture and sound) after calculating and processing what it's been given.

It's a black box (literally, for most TVs) that we don't need to understand the innards of in order to make it work. But not all functions must be as complicated as a TV. You probably know how a flashlight works, and could make one if you had the right materials at hand. If you've had training in soldering components to a circuit board and know enough high school level electronics you could probably assemble an FM radio too. And once either device has been put together, operation of it is much much simpler than the assembly of it.

It's like that in programming. Quite often you'll have a -process- that you need to make use of multiple times in the same program, or even in other programs too. Or, someone else will have written one that you'd like to make use of. Let's say you've written code that calculates how much you'd earn if you charged $10 per hour to build flashlights. Let's also assume that you want it to subtract expenses such as coffee and pretzels, which you consume at a regular rate while working and cost $1 per cup and $0.25 per packet, respectively. The code would probably look like this, assuming we've stored all those factors in variables already:

Earnings = (hours * 10) - (hours * (1 + 0.25))

If you needed to calculate this several times in your program (we'll assume you make FM radios at $10 per hour too) it'd not only be more convenient, but it'd also reduce the chance of error if we could use the -same- code. And you can, if we package the code like this:

CalcEarnings: *procedure*
hours = *arg(1) *
Earnings = (hours * 10) - (hours * (1 + 0.25))
*Return* Earnings

Lets dissect this. The first line begins with "CalcEarnings:", the colon tells Rexx that this is the name of a function. Be aware that a function name must *not* contain any spaces. If you need to separate words, either use mixed caps like I did, or use an underscore ( _ ).

The word after that colon, *procedure*, tells Rexx that this should be considered an independent module of code. In effect, it makes sure that variable names won't get mixed up. We can create variables within the function, name them whatever we like, and not have to worry about them conflicting with others that are outside and have the same name. *procedure* creates a new "sandbox" for the function to operate in.

The second line assigns the first parameter (argument) to a new variable called "hours". *arg(1)* retrieves argument number 1, and if you happened to need more than one argument/parameter you'd use arg(2) and arg(3) and so-on, putting them on new lines and assigning them to new variables.

The truth of it is, you could skip that "hours = arg(1)" part and just use "arg(1)" in place of the variable name "hours". But we want to get into the habit of doing it the wordy way early, since it becomes a pain in the rear to change all of those instances if you have a big function and want to insert another argument somewhere.

The last line, beginning with *Return*, tells Rexx to return the result of the calculation (stored in "Earnings") to whatever invoked it.

So how do you invoke it, and -what- exactly invokes it?

Remember how you learned to assign values to variables at the beginning of the series? We do exactly the same thing here, because now if you worked for 6 hours, the line of code that -calls- our new function "CalcEarnings" looks like this:

Earned = CalcEarnings( 6)

And the result of all the calculations gets stored in the variable called "Earned"

Rexx sees the name "CalcEarnings", looks around in various places for a function called "CalcEarnings", and when it finds one it runs it. You just have to put the function where it can find it, the traditional place for -user-defined- functions being just after the main code of the program. Here's an example that spells it out:

/* Calculate Earnings */
Say "How many hours did you work today?"
Parse Pull Hours
Earned = CalcEarnings( Hours)

Say "You earned $" Earned

Exit

CalcEarnings: procedure
hours = arg(1) 

Earnings = (hours * 10) - (hours * (1 + 0.25))
Return Earnings

The "Exit" inbetween the main section of code and the function makes sure that Rexx doesn't accidentally run the code in "CalcEarnings" after it's already used it in the main section.

More to come in the next installment of this exciting series!

***********************************
The companies that made this issue possible

The following are the companies that made this issue possible.

(http://www.rsj.de) RSJ Software
The successful software CD-Writer for OS/2 by RSJ. CD-Writer is suitable for backup, data filing, creating Audio CDs etc. and is compatible with most CD-Recorders.

(http://www.crosstec.net/) CrossTec
NetOp - A cross-platform solution to remote-controlling any PC from anywhere in the world.

(http://www.prioritymaster.com/) ScheduPerformance, Inc.
Dramatically improve performance on your OS/2 system now with the patented priority scanning logic and visual priority identification of Priority Master II.

(http://www.vacentral.com/) Prominic Technologies, Inc.
On-line sales &amp; solutions for VisualAge, DB2, OS/2 Warp, Workspace on Demand, Notes/Domino, AIX Firewall, and Net.Commerce (design/hosting).  The best deals on IBM and Lotus software and hardware (PCs, Servers, and RS/6000s) -- with OS/2 preloads!

(http://www.bmtmicro.com/) BMT Micro
Your complete source for over 175 of the best OS/2 shareware applications available.  Drop by today and check out our WWW catalog or download the .INF version.

***********************************

Subscribe for FREE

If you would like to receive notification when new issues of OS/2 e-Zine! are posted or remove yourself from our notification list, use our on-line subscription form at http://www.os2ezine.com/subscrib.htm -or- send an e-mail to subscribe-request@os2ezine.com with only the word:

subscribe

in the body of the message.

Please make sure your software is properly configured with your e-mail address!

If you have problems please (feedback@os2ezine.com) e-mail us or contact us at:

Falcon Networking
4302 NW 25th Terrace
Gainesville, FL 32605

800-595-1974 (US and Canada)
352-335-9693 (elsewhere)

***********************************

Sponsor OS/2 e-Zine!

Corporate Advertisers

OS/2 e-Zine! has space for a very limited number of corporate advertisers.  A variety of affordable high impact, inline graphical advertising options are available.  Arrangements are available for multiple issue insertions.

For more information please (sales@os2ezine.com) contact us via e-mail or phone 800-595-1974 in the US and Canada or 352-335-9693 elsewhere.

Readers Can Sponsor Too!

If you feel OS/2 e-Zine! is useful, entertaining or educational, please send whatever 12 issues are worth to you.  Even sponsorship of a few dollars is appreciated.  Individuals sponsoring US$ 15 (or CDN$ 20) or more will be listed in our Sponsors Page (with an optional link to their home page).

Please (feedback@os2ezine.com) send cash, cheque or money order (International or US, made payable to Falcon Networking) along with:

o A note stating that your contribution is for OS/2 e-Zine! sponsorship
o Your name
o Your address (city, state/province & country)
o Your e-mail address
o Your web URL if applicable.

Alternatively, you may choose to sponsor OS/2 e-Zine! by credit card through (http://www.bmtmicro.com/catalog/ezine/) BMT Micro, Inc.  BMT Micro accepts Visa, Mastercard, Discover, American Express, Diner's Club, and many other credit cards.  Just call:

(800) 414-4268 (Voice) 9:00am - 7:00pm EST
(910) 791-7052 (Voice) 9:00am - 7:00pm EST
(910) 350-2937 (Fax) 24 hours a day
(910) 350-8061 (Modem) 10 lines, all 14.4K, or
(910) 799-0923 (Modem) Direct 28.8K line

Or, use BMT's Secure Order Form (https://secure.falcon-net.net/BMT/order0261.html).  It's safe, fast and simple!

Remember, any amount is appreciated and whether you choose to sponsor or not, you will still be able to enjoy every issue of OS/2 e-Zine! on the WWW!

For more information or any other questions please (feedback@os2ezine.com) see our contact information.

***********************************
Copyright 1999   -   Falcon Networking
ISSN 1203-5696



