For Linux, The End-to-End Is Near

Native Linux development tools work well for what they do, but true enterprise acceptance will lead to life-cycle solutions

By Andrew Binstock

July 15, 2005 —

For a community that was built byte by byte through the hard work of programmers, it is surprising that Linux does not occupy a more central position in the world of development tools.

For years, Linux has made do with products that were sufficient but not exceptional. At the center of the development universe were tools like gcc and emacs, which were the favorites of a vocal minority but did not represent the larger state of the art. And during the years of its emergence, commercial tools vendors were greatly skeptical of stepping into the Linux market to provide the better products.

This skepticism was based on the perception that Linux users would not pay for the tools (which certainly had some truth to it). The few hardy vendors that stepped into the market, such as Borland with its Kylix port of Delphi, soon came to regret the move. Even IBM’s significant commitment to Linux—a step that did more to legitimize the operating system in the enterprise than any other—did not result in a flood of Linux development tools for the platform.

The commitment came first; the tools showed up much later. In sum, the Linux market was a conundrum for tools vendors that saw an audience waiting for better products but unwilling to support the vendors or write the products they needed.

During the past few years, the composition of the Linux market has changed significantly as the operating system has gone mainstream. The rabid expectation that all tools on Linux should be free has been tempered, and as a result more commercial products are finding their way into Linux developers’ toolkits. Likewise, open-source tools have improved significantly.

While this trend augurs a future replete with excellent programming products, the current reality is that the Linux toolchains still suffer from a number of weak links.

Compilers
The history of the modern open-source movement begins with Richard Stallman’s two landmarks: his modification of James Gosling’s emacs editor and his design and implementation of the gcc compiler. Today, gcc still remains the default compiler in the Linux toolbox. Its original C and Unix orientation has been broadly expanded so that it now supports numerous languages that have a common heritage in C. It generates binaries for an extraordinarily wide range of execution platforms.

(Actually, “platforms” is a slight overstatement: gcc generates binary code even for Donald Knuth’s MMIX virtual machine—a hypothetical platform that appears in Knuth’s writings as a machine on which algorithms can execute and their operation can be analyzed.)

While the great strength of gcc is its portability, this protean dimension comes at a distinct cost: Generated code is slow. Optimizations added over the years have improved performance, but the binaries still lack zip.

Until recently, the commercial choices to solve this problem were limited to specialty products, such as the Portland Group (now a part of ST Microelectronics), which sells compilers for parallel programming.

Then, two years ago, Intel ported its C/C++ compiler to Linux. This product, whose front end was redesigned to be compatible with gcc (at the level of command-line switches and binary formats), produces stunningly fast code. It not only performs all the static optimizations, but it adds profile-guided optimization (PGO). This step embeds instrumentation code into the binary.

During the optimization stage, the application is run several times and the instrumentation provides a statistical profile of the execution paths. This profile is then fed back to the compiler, which recompiles the code and optimizes again, this time making the most common execution paths as fast and as short as possible. The result is that just recompiling gcc code with Intel’s compiler can result in performance gains of more than 40 percent over gcc binaries.

The GNU project, however, has other interesting compilers it’s working on. None of these is more interesting than the GNU compiler for Java (gcj). This tool compiles Java code to binaries rather than the traditional bytecodes. Although the performance report cards on these binaries is mixed, this approach does have the benefit of enabling distribution of applications that do not require the Java runtime environment (JRE), which also makes programs more difficult for crackers to reverse-engineer.

For gcj to work, though, it required linkable versions of the Java libraries. Two open-source versions exist at present: libcj, which is being merged into the other library, classpath. This summer, the Apache Software Foundation announced it will coordinate a new push to write an open-source set of Java libraries, which when done, will add a third option.

Linux needs more good compilers. And, fortunately, the platform’s increased acceptance is attracting products: C# (Mono Project), COBOL (Acucorp, MicroFocus), Fortran (from Intel, Portland Group) and Visual Basic (RealBasic).

Libraries
Due to its Unix origins, Linux is an environment that is comfortable using many different libraries. And early Linux history is rife with all sorts of libraries being developed by individuals or small bands of programmers. Many of these, such as the GTK+ graphical toolkit, persist in the GNU collection, while different open-source libraries are maintained under the auspices of other groups.

A number of these libraries have distinguishing features that derive from Unix and that make them an unnatural fit for Windows environments. Ports of these libraries to the Windows platform often look and feel like second-class citizens, and they tend to have specific requirements. Of these, the most common is the need to use the Cygwin library (www.cygwin.com), which duplicates some of the Unix/Linux functionality on Windows.

Some libraries, though, are designed from the ground up for portability. And these libraries underlie most of the important Linux products today. These include Netscape’s Portable Runtime library, written in C; its present rival, the Apache Portable Runtime, which is very much a work in progress; and the ACE Toolkit, which specializes in networking and distributed computing functions.

The most comprehensive and portable library on Linux today is certainly Qt from Trolltech, which started out as GUI toolkit, and is today the basis for Linux’s K Desktop Environment (KDE). Qt is a remarkably clean, intelligently designed and elegantly implemented library with portability to Windows and Macintosh platforms built in. As such, it forms the basis of many commercial Linux tools.

One historical drawback to Qt was its unique dual-licensing model. The library was provided at no charge for free, open-source projects on all platforms except Windows. Projects that were not free and open source, or any project on Windows regardless of status, required payment for a license. Qt 4.0, the latest release, changed this model and removed the Windows exception. Now, any free, open-source project can use the library at no cost. I suspect this will lead to Qt’s becoming the de facto library for many Linux-based projects.

Build Tools
In days when programs consisted of a few code modules and a handful of resource files, build utilities such as make were sufficient. Linux relied on the open-source gmake during portions of its formative years. However, as packages have become more complex, especially in Java, where each class requires a separate compilation unit, gmake has been forced to give way to more robust tools. Ant is the most widely used of these. It uses an XML-based syntax to specify the sequence of build steps and the action each step requires.

Ant might eventually be supplanted by Maven, an open-source project of the Apache Software Foundation. It is based on Java and uses the concept of plug-ins to provide processing for the different kinds of files and the actions that a build process might require. Tools such as Ant and Maven are driving the build step into a more plenary process that includes running tests, compiling files, validating resources and generating documentation. These actions make the assembly of software products more accurate, more predictable and more scalable.

These tools work in conjunction with source-code management (SCM) products. SCM is an area in which Linux has traditionally shined. The two major open-source products today—CVS and Subversion—derive from work done by Linux enthusiasts to provide better developer collaboration. Both SCM products are in wide use today, although Subversion is slowly but inexorably taking over from CVS. These two tools are complemented by a wide range of commercial products, including IBM Rational ClearCase, Perforce, Seapine’s Surround SCM, Serena’s ChangeMan Version Manager (formerly PVCS), Catalyst’s Openmake and a few others.

IDEs
The question of development environments remains a touchy one for Linux hackers because of their long-standing love affair with emacs and its various spin-offs. The original emacs community from Unix days added numerous plug-ins to the environment, some of which were truly useful, others purely whimsical. But all of them added to the lore of the product. And Linux users added even more modules. For some developers, emacs represented an environment they could not foresee ever leaving.

This historically great attachment, however, has been giving way to a new reality imposed by the complexity of modern software. For programmers to be sufficiently productive, pure code tools are no longer enough. As a result, according to surveys done by BZ Research (a division of BZ Media, publisher SD Times), visually oriented IDEs such as Eclipse have been steadily climbing in their adoption among developers to the detriment of text-oriented environments such as emacs.

Several open-source projects offer Linux IDEs today, notably Anjuta and Kdevelop, both of which are polished products. However, Eclipse is emerging as the 800-pound gorilla in the open-source IDEs, especially now that its C/C++ plug-in has improved considerably. While not quite at the same superior level of sophistication as its Java support, the C plug-in and others under development will surely catch up soon. At that point, I believe they will become the de facto IDEs on Linux and Unix.

Other good IDEs, mostly derived from the Java ambit, include IDEA from IntelliJ, Rational Application Developer from IBM, and NetBeans from Sun. Niche IDEs that were built in the Linux community can still be found in specialty areas, such as ActiveState’s Komodo environment, which is focused on scripting languages.

Full Toolchains
The Unix genes that influenced Linux run counter to the model of a true end-to-end life-cycle management toolchain. The operating system is more oriented toward a series of point products that form a mosaic, rather than a smooth set of integrated tools. For this reason, Linux can be very strong in some areas (SCM, for example) and much weaker in others.

Because end-to-end development toolchains don’t come naturally to Linux, most of the companies that provide them today are carpetbaggers of a sort that have brought the model to Linux. Their arrival, fittingly, parallels the broader acceptance of Linux in the enterprise.

Today, such toolchains are shipped only by Borland and IBM. Borland’s SDO product line is a complete product chain that is heavily Java-oriented. IBM’s Rational products also heavily favor Java, but they do support work in other languages, notably C/C++. The Java orientation is not surprising, however, since Java is the language of the enterprise, which is where heavy, integrated tool sets make the most sense. Interestingly, Linux could not currently assemble point products into a true end-to-end suite because of weaknesses in certain key areas, such as requirements processing and integrated design products. However, the fact that Linux has come this far during the past few years bodes well.

New development products and updates to existing commercial products now routinely include Linux (with the notable exception of those originating from Microsoft). And so, it is fair to expect that within a few years’ time, the Linux development market will have many more tools with richer collections of features from which to choose.

Andrew Binstock is the principal analyst at Pacific Data Works, and writes the Integration Watch column for SD Times. He can be reached at abinstock@pacificdataworks.com.

Share this link: http://www.sdtimes.com/link/28733

Microsoft exhausts coupons for SUSE Linux Microsoft will continue paying to support Linux users as they move to SUSE

Coordinated effort at IBM brings new Linux servers With the Series z Linux Server release, IBM is realizing its efforts to unify its services, hardware and products

Visual Studio Mono add-on brings .NET apps to Linux, Mac OS X This new tool facilitates cross-platform development by enabling development and testing of Visual Studio applications

Add comment

Name*
Email*
Country

Comment
Preview

News on Monday
more>>
SharePoint Tech Report
more>>

Download Current Issue
ISSUE 3/15/2010 PDF

Need Back Issues?
DOWNLOAD HERE

Receive the print Edition?

Google Code turns 5
Google Code Turns 5, and adds a Paxos Algorithm to make the system more stable and reliable.
03/17/2010 11:16 AM EST

Test your Visual Studio 2010 know-how
Microsoft is offering free beta certification exams for Visual Studio 2010.
03/17/2010 11:08 AM EST

Microsoft lifts the hood on IE9
Microsoft is previewing IE9.
03/16/2010 01:10 PM EST