Kawa IDE offers no-frills Java development

Choosing a Java IDE (integrated development environment) isn’t as simple as it might seem. Before taking the plunge, you have to drill through a complete needs-based assessment, and one of the first things you must address is the degree of hand-holding your developers require.

TEXTBOX:

TEXTBOX_HEAD: The Bottom Line

Kawa 4.0

Business Case

For a minimal entry price, Kawa delivers solid development features to improve productivity in Java coding. Version-control capabilities make it ideal for team-based projects, and the capability to wrap around multiple JDKs ensures solid long-term return on investment.

Technology Case

Code-level access lets developers maintain strict control over development. However, Kawa’s lack of wizard-driven editing features makes this an IDE best suited for experienced programmers.

Pros

• Direct access to code
• CodeWright editing features
• Fast debugging engine
• Strong version control

Cons

• Limited enterprise integration
• Limited plug-ins available
• Minor bugs

Cost

29 per seat

Platforms

Windows 9x/NT/2000

Tek-Tools Inc., Dallas; (972) 980-2890

:END_TEXTBOX

Usually it all boils down to a matter of experience. Many junior programmers work faster with visual IDEs, which spruce up the stark command-line interface of the modern JDK (Java Development Kit) with user-friendly refinements. But to senior developers, bells and whistles only slow them down by distancing them from the underlying code structure.

Tek-Tools’ Kawa 4.0 is the kind of streamlined IDE meant for experienced Java programmers who don’t want to burrow through graphical frills. Unlike competitors like Symantec Visual Café and Inprise JBuilder, Kawa doesn’t have any wizards, database client-development capabilities, large source-code samples, or drag-and-drop tools.

The package also lacks some distributed application development beans, such as CORBA support, making it more appropriate for small and midsized team development or lightweight enterprise integration. Meanwhile, the absence of tools for GUI construction suggests a role in server-side or backend application development, where a GUI isn’t required.

But Kawa’s suite of project-management, editing, and debugging tools lets developers keep their hands in their code while building Java applications and applets. The package, a 32-bit Windows application that wraps around any version of Sun’s JDK, also boasts a set of editing features lifted from Premia CodeWright along with new version-control enhancements, EJB support to encapsulate business logic in distributed applications, and a fast debugging engine. At 29 per seat, it’s considerably more affordable than such high-end visual tools as Inprise JBuilder and Microsoft Visual J++.

For most developers, Kawa’s biggest attractions are the newly integrated CodeWright features. Thanks to CodeWright, this version of Kawa offers easier source-code management, formatting tools, multiple clipboards, and a spelling checker.

I was especially impressed by the differencing and merge utilities, which can drastically reduce the time spent on analyzing code. With these tools, you can quickly sift through several sources and view identified differences side by side. You can make changes to your code from within the differencing window, or backtrack through previous versions of your documents.

CodeWright also supplies a code beautifier, a handy utility that formats your code to customizable specifications. This way you can set display parameters, including indentation or keyword colors for a particular programming language. Features such as these go a long way toward standardizing output and improving code readability in team-based environments.

In addition to the CodeWright additions, Kawa’s code editor also boasts a search-and-replace tool for making bulk modifications, code folding capabilities, and improved printing and previewing tools. My only complaint: the editor did not permit screen splitting for multiple views on a file — a simple tweak that would be useful when working with large codebases.

Meanwhile, version-control enhancements let you sign documents in and out or review modification histories by simply pointing and clicking. Easily identifiable icons quickly reveal your documents’ read/write availability.

Other features include a fast debugger and variable watch window, which make debugging with Kawa a much quicker process than debugging with Java-based IDEs like Sun Forte. True, the debugger could benefit more from features that are found in the more advanced debugging engines, including remote or just-in-time debugging. But Kawa’s debugger still provides such reliable basic capabilities as breakpoint settings, stepping, and variable browsing. You can even debug servlets as they interact with a Web browser.

Kawa scores more points for its straightforward interface, which presents no challenge to getting started. The project management center displayed a hierarchical listing of the projects I was working on, as well as the packages and classes available from the current JDK. This layout helped me track ongoing projects: I could see multiple projects and quickly access version control without having to switch between applications. I could also build and save setting profiles, making it easy to adapt Kawa for multiple projects and small team settings. And the abilities to switch between JDKs and generate javadoc files without leaving the IDE boosted my productivity.

I did, however, experience a number of buggy interactions, such as display errors that prevented new files from displaying correctly (restarting the program temporarily corrected the problem). Thankfully, most of the bugs I came across, such as the flag which was supposed to indicate successful compilation but which never worked consistently, were more nuisances than actual detriments.

A bonus toward extensibility is that Kawa workspaces and projects are now stored in XML. This will help improve the portability and readability of the workspace environment to enable easier migration with external, third-party tools.

The Kawa architecture is even further extensible via the use of a modular Java plug-in API, which could come in handy for doing things such as connecting to external source-code servers. Tek-Tools is still developing this feature, so the plug-ins available now are limited to general source-control classes such as a new project alert and interpreter settings. But the company promises new plug-ins for future iterations.

Until Tek-Tools beefs up Kawa’s distributed application development capacity, Kawa isn’t suitable for large enterprise use. But for small and midsized team development, this is one of the best little no-frills IDEs I’ve ever seen. Kawa represents an excellent low-cost alternative to high-end IDEs, making it worth a look for experienced Java developers in need of a standardized, team-based platform.

Source: www.infoworld.com