Christoph Vogelbusch is an avid OS/2 Netlabs supporter, the OS/2 community's largest open source software development effort.

If you have a comment about the content of this article, please feel free to vent in the OS/2 eZine discussion forums.

Creating Native OS/2 Software

This article does not define "native software" -- I think this is common knowledge to everyone using OS/2. This article deals with two things: first, the hard to see relationship between porting projects to native software, and why these are absolutely needed for the future of native software development, and secondly how we can satisfy our need for native software with our limited resources of programmers.

If you know the criticisms against porting software, it should be obvious why I deal with the first part. I deal with the second part because the "Netlabs idea" is mostly misunderstood, and believe that THIS is where the future of OS/2 software lies.

Part One: Ports

Odin

Odin is the well known project that opens OS/2 to the world to Win32 software (that is Win 9x/NT software). The ported programs are not native software of course, and they do not behave as if they are native. But there are Win 32 programs that are absolutely needed, such as Word, the Realplayer or smaller specific software (for programming your phone or whatever). So we have two choices: either everyone has to have a Win32 platform on his computer, or we write a clone.

But who wants to reboot every time he wants to view a Realplayer file? So the only real choice is to write a clone. But if you know anything about what we're cloning, you also know there's a lot to do -- and while you cloning it, the target is moving away. And those targets are moving fast.

So instead of constantly producing out-of-date clones, Odin decided to build a base on which you can use the needed programs directly. It's not as native a clone, but you don't have to reboot -- the best clone is the original.

I don't know if cloning would take less time than Odin, but I know that getting information on the Word files, Realplayer formats etc is not that easy and Odin has a lot bigger side effect.
First, some later versions of a program already work without changing Odin. A Clone has to implement all the new features. Secondly, some people will never get an application if they're waiting for a true clone clone... like the phone-programming tool (or Gnutella, which is already working with Odin).

This allows developers to be more selective about what to clone as a native application. With Odin, you don't have to clone Word (as it's too big and too fast moving) but you can clone Napster to implement WPS integration, or include it in the SysBar pipe monitor, for example.

And don't forget, Odin can also help you use Win32 code under OS/2. So if you can get the source to PowerArchiver you can use it to build an OS/2 front end, so that you have built an archiving tool that supports nearly every type or archive with a minimum of work.

*nix ports

First, when I say "*nix" we all think of Linux. But this isn't necessarily true, Linux is just one platform that all the GNU and other *nix progs are compiled for. It's the free distribution that makes Linux ports so common, but if you compare speed and stability you'll see that other Unix platforms have many advantages. Second, "port" is the wrong word of course. It's only used because it's a lot of work some times to get a *nix prog compiling and running under OS/2, as there are bigger differences than between the different *nixes. But if you think of the idea behind GNU (Gnu is Not Unix) you realize the OS/2 is just one platform like the others that the program is compiled for.

There are two kinds of *nix ports, the text mode ones and Xfree86 ones. They all have something in common: their development is continued without any OS/2-programmer's manpower, and mostly it's continued quickly. So if we port a program once, we have a good chance of getting an up-to-date program with a minimum of work next time.

Text mode ports can be divided into command line tools and those with a VIO-interactive user interface.

Command line tools are popular if you're talking about native software, as there is no difference between these and native OS/2 command line programs, except that you need EMX. And it's a lot less work to port a program than it is to write it from scratch. Instead, you port the prog and either provide from it's development or also work on it. And there are not only normal programs to port like wget, but there are also a lot of (hardware) specific apps out there, such as cdrecord (CD-burning) or SANE (scanning).

Command-line-ports are also used as a starting point in order to build PM-Front ends. So you don't have to care about any specific work of the program, but only for its usability. And this was (maybe still is) one of the easiest ways to work together on a project, one programmer working on the front end and one working on the back end.

VIO-programs are not as popular, as it is sometimes complicated to solve their problems with the character set and special keys (like arrows etc). But if they are ported correctly, once again the program doesn't have to be developed by OS/2-programmers. So you can get great programs with little work such as the Midnight Commander (Norton Commander clone with FTP enhancement) and sometimes it even possible to build a PM front end like we have with EMACS (programmable editor, with Newsreader, web browser, mail client, syntax highlighting (for Tex, HTML etc)).

Xfree86 ports are all different, but they all have in common that you run an X-Server on your OS/2 system. This is the biggest criticism for these ports. Xfree86OS/2 is absolutely useful (e.g. for remote programs) but it's inconvenient to have to leave the WPS to run a program. So if there are Xfree86OS/2 programs that could be useful for OS/2, the most important step should be getting them to the PM and one way to do this is with the Everblue project. And to answer the question, there are Xfree86OS/2 programs worth porting, specifically there are two kinds of GUI-Toolkits with a lot of software: GNOME and KDE.

GNOME/2 is a project with the goal porting the most needed GNOME-apps to OS/2. Therefore the team has to port the GNOME libs such as Orbit and GTK, which is very hard and the team is often seeking help in finding bugs (see below if you want to help). But the profit of this painful work is well known: GIMP (great graphic prog), Gphoto (Digital Camera transfer utility), Gnokii (Nokia cell-phone communication suite) ...

One reason why such programs are ported has been said, e.g. it would take too much time writing a program like GIMP. Another reason is, that some code includes a lot of hardware specific stuff like Gphoto and Gnokii does. This hardware information is easier to get if you say "I'm working on a Linux program" than for any other platform, AND if you have a big community that needs your program, so you have a lot of testers.

So if these programs are wanted under OS/2, and there is no easier way to get them, they have to be ported. The biggest job to be done is getting them to the PM. At the beginning Everblue thought about only porting the GTK to the PM, but the changed to porting the whole Xlib. Another possible (but slow) way is having a X-Server included in the PM. The last and hardest way is to rewrite the GUI of a prog. This is an idea that hasn't been tried yet, but it's not much more work than building a code-internal front end (only the code is a lot more confusing and you need to know it very well).

KDE/2: Like GNOME, KDE also has a big bunch of software and there is more to come. The OS/2 port has only been started, but it will be interesting to see where it's programs can help OS/2 filling leaks.

A few other programs use different toolkits, but those are mostly smaller and sometimes even included with the program source.

A lot of people wonder, if all the Xfree86OS/2 programs are ported only when they are needed, why is there so much junk? That's easy to answer: If you already have the basics ported, a few programs can be ported without much work. And if you like a program, why not port it to OS/2 instead of booting to *nix every time you want to run it? On the other had you should never forget that there's not only needed programs, but also a lot of fun stuff out there. So if you'd like to have a SimCity under OS/2 you can either buy the old OS/2 version, use a *nix with LinCity or use the OS/2 port of LinCity, but there is no need to rewrite SimCity for OS/2.

The Netlabs idea

In my eyes, Netlabs is simply the solution to the biggest OS/2 problems: dead software and 20 unfinished software packages with the same goal ...

I think I don't need to explain more, you know exactly what I'm talking about. This is the pain of OS/2. But the solution could have been so simple: be sure software won't die and make certain that there isn't already a program out there before another 19 are started. The solution for such problems is Open Source Software. Projects can't die, and people can work together on it though CVS. And if you really want your own software you don't have to start from scratch, but can use the existing code of a project. Even this is a bad idea, as you could also implement all the features you wanted to have in an existing project without separating. I want to give you an example:

X-Workplace

I know it's not up to me to write about it, but it explains what I wanted to point out.

A great thing about OS/2 always was and is the WPS, but after some time you'll notice it's missing some features. Therefore there are a lot of WPS-Enhancers all with great features. But after a short time the fun has gone again, when you figure out that some WPS-Enhancers won't work together correctly. (And did you notice how many same features they have?) So what X-Workplace does is give the programmers the chance to add all their features into a single piece of software. What the programmers have to do is not to write all the stuff with the common features and the basic enhancements, they only need to add their feature and that's it... so they have more time for writing other features. What the users get is ONE WPS-enhancer, so no more collisions between enhancers... and one user interface.

But X-Workplace has gone a step farther, as you can choose which classes shall be overwritten, so that features can REALLY be disabled when necessary, so you have the features, but not the problems. At the moment, this is not the reality because the product is still alpha and developers are missing.

Currently Ulrich Moeller is nearly doing everything by himself (thanks a lot Ulrich, we know what you're doing). There aren't even any guest programmers who add their own features. What's the problem, why are you still working only on you own software?

But this should also be an example ...

Positive side-effects

Of course working on an Open Source project at Netlabs is a good thing for users and programmers, so that Freeware programmers should think of joining, but the Netlabs Organization also has a lot of other positive side effects. For example, Netlabs is the perfect place where you can donate discontinued software, so others can learn from its code, or continue developing it.

An example for this could be HandyFTP, which includes a lot of great ideas, but was discontinued before it's first non beta came out, because the author was involved in a lot of other projects. Now this source is at Netlabs and can be continued. This software could be developed with the same potential that X-Workplace has, where guest programmers can add their wanted features.

Another positive side effect is that Netlabs is the place where new ideas can be born, as it has a database with ideas for new software, so developers can get great ideas, either from non-developers or busy developers. The same goes for existing software, non-developers can have great ideas, for example with X-Workplace, but could never realize it on their own... but with this way it's possible for the idea to be realized by someone else.

But Open Source also influences up-and-coming new developers, as existing source is a great point to start programming. You only have to understand the code to add a few lines. This is not as easy as it seems, because setting up a properly configured GCC-Environment is not as easy as it sounds. So we have to build out of the box environments and collect and write Tutorials ... (it's still a log way to go).

Conclusion

To give OS/2 the software it deserves and allow us to have a powerful Office/Home environment, we need to use all the resources we can get. That means we should try to port as many apps as we can and have them run as close to native applications as possible. And we should try to use our own resources as carefully as possible, which means we have to work together in the future. The solution here is Netlabs. Currently it is only a Webserver, so we have to fill it with life. Go join projects, build your own, be sure we have at least one program of a kind instead 20 WPS-Enhancers and Config.sys editors (with nearly the same features), but nothing else. Don't be shy or think you have too little time to be on a project. Adding a single feature to a software is better than keeping out of it entirely.

Non programmers ...

... can also help. Of course they could learn programming, but there are also other ways. They could try to support programmers, for example by making their homepages or testing programs. Or help the OS/2 community get organized, by making unknown programs popular, filling Hobbes and LEO with stuff you found etc.

And NEVER KEEP YOUR MOUTH SHUT, when you have an IDEA or find a BUG.

Previous Article

Home

Next Article