[ Home | Library | Contents ]

[ Prev | Next ]

by Matt Slot

Does Size Matter?

Most commercial software today has to serve a large number of people, which means supporting as many features and as many operating systems as possible. To manage the complexity, software engineers design software to be object-oriented, cross-platform, and numerous other buzzwords.

Unfortunately, this leads to monolithic applications, that soak up resources like memory and disk space -- but also design and development time as well. While they are powerful, such software is bloated and pretty much requires the work of a development team.

On the other hand, not all successful software needs to be huge. In fact, most freeware and shareware products are small, focused utilities which perform mundane tasks but consume very little memory. A novice programmer can gain a lot of experience writing something small but useful, instead of diving into a large or esoteric project that he has no chance of completing.

Even experienced developers can take advantage of prototyping or lightweight development tools to create simple utilities, such as map editors or file filters. Moving rarely used features to separate applications can simplify a user interface and makes for faster bug fixes.

Finally, some tools are simply better suited to specific tasks than others. There is a reason that most UNIX text utilities are written using Perl and not C++ or Java -- Perl is very good at file and string manipulation, doing in 5 lines what may take 100 in a "high level language."

Going retro

There are many tools that can create small utilities. Scripting languages and visual tools are both excellent ways to bootstrap code, but just plain C or C++ without class frameworks works very well too. In the end, the environment isn't as important as the development process and finishing the product.

As I mentioned above, Perl is an excellent tool for managing text -- but it also provides interprocess and network communications. It has become very popular with sysadmins and webmasters, who often need quick utilities for generating reports or web pages. There are actually many text oriented tools used on UNIX systems, such as expect, awk, and shell scripts -- but Perl has certainly become the leader.

While most "serious programmers" tend to look down on BASIC as a programming language, it's also a very popular and useful tool. Visual Basic for Windows and RealBasic for the Mac OS provide simple drag-and-drop constructors for building the skeleton of a graphic user interface. It's easy to assemble a set of dialogs and document windows, then insert the logic to manage them.

In addition to performing common actions, BASIC software can be extended by writing custom modules to handle specific tasks (compression, encryption), interact with hardware (play sounds, network), or do time-critical work (animations, data processing).

BASIC is also a great way to prototype very complicated software, quickly designing and revising the layout and flow of documents and dialogs. Prototyping shakes out many design issues early in development, and provides a working mockup that the developers can refer to while building the "real" product.

On a related topic, component software is a great way to provide reusable services without committing to a large application. ActiveX and CORBA are very popular systems for managing modules, but even a shared library can be a powerful element when bundled with other tools.

Tools like Hypercard on the Mac OS are still used to create lightweight databases for address books and compact disc catalogs. AppleScript, in conjunction with FaceSpan, is great way to automate a complicated sequence of operations that span applications.

Finally, I don't want to forget about those monolithic applications which provide macros or other automation to capture, modify, or output document data. Microsoft Word and Excel have very complicated (and often abused) macro environments. Many relational databases can summarize entered data into reports while saving them to the server. If the data is already going through one of these tools, just use the features at hand.

Baby steps

If you are bound and determined to make a killer application, then you are likely to dive into the development process head first. If you are smart, however, you should realize that slow and steady progress is much more reliable and convenient.

Design and implement projects in moderation -- decide the core features, implement them, and send out a version. Inevitably, user feedback will indicate what features to add next, but it will also stroke your ego and make it much more likely that the product will grow and flourish.

Use the right tools for the job. Don't be afraid to make something that performs mundane tasks in a new, simpler way -- but do it efficiently. Write the first version in Perl or BASIC, establish a following and then worry about how to improve. Eventually you may move onto native C code or a full C++ framework -- but leave that worry until it's actually worth the time.

Matt Slot, Bitwise Operator

[ Prev | Home | Library | Contents | Next ]

Copyright ©1995-9 by Ambrosia Software, Inc. - All rights reserved