Openadaptor is a software toolkit that may be classified as a lightweight Enterprise Application Integration (EAI) solution. It provides a configurable component framework for connecting various systems and middleware implementations. In less technical parlance, the components are akin to Lego building blocks that users can snap together to build adaptors, which themselves are the metaphorical glue or plumbing between applications.

This article presents a case study of the use of meta-programming in Java compatibility testing. It shows how parts of the source code can be shared between different products and modified to generate programs targeting specific functions and describes the approach Sun Microsystems has used for building Technology Compatibility Kits (TCK) for more than five years.

The mouse was the original idea of Doug Engelbart who was the head of the Augmentation Research Center (ARC) at Stanford Research Institute. Engelbart's philosophy is best embodied, in my opinion, in the design of another device that he invented, the five-finger keyboard - with keys like a piano, used by one hand. The problem was, Engelbart's five-finger keyboard and mouse combination was very difficult to learn.

I target customers who have large data processing needs. These come in various forms, but generically look like this: the customer gets huge data drops in some form or another and must process the data and output results in a very specific time frame. The customer has written some scripts, maybe some code and SQL. They have attempted some optimizations that helped a little, but they're not meeting their timeline.

Each day as an AJAX developer seems to bring another helpful revelation: a new tool, a new gadget, a new way to reinvent the browser. But even when I'm confronted with a breakthrough as big as Firebug - the brilliant debugging tool for Firefox - in the back of my mind I'm reminded that the AJAX state-of-the-art is trailing behind the debugging tools that we've had in Java for years. With age comes maturity, and with Java's maturity has come a wealth of development environments, field-tested frameworks, and a rich set of strongly typed APIs.

Software professionals usually take a great deal of pride in some combination of: Chasing and groking the latest software methodology/technology (e.g., AJAX, JPA, PMP, Spring JMS, Ruby, etc.) making them more marketable (and better positioned to pay their bills!). Creating software products and libraries (open source included) that can be reused (the DRY principle) by other technologists, Building and deploying software projects that are successfully used by their business customers.

The term Software Archeology has been used in various forms since early 2001. The concept of Software Archeology is an approach or methodology that helps individual team members or entire teams to understand exactly what they have in the code they're going to be working on. The approach is also very useful when deconstructing an existing piece of software to find patterns of design and development that could be 'harvested' in future developments.

Roughly two years ago, when I was writing an article on 'New Features for Device Developers in Visual Studio 2005' that was published in the August 2005 issues of this magazine, our program management team was already busy shaping the next release of the product, which is soon to be released as Visual Studio 2008. We spent a lot of time talking to our major customers and reviewing the feedback we got on blogs and questions on forums on newsgroups to identify what enhancements/features would be most useful to our device developers. One thing that surfaced was that device developers needed more help when it came to testing their applications efficiently. Whether that meant testing on multiple devices or under varying conditions or simply being able to write unit tests, they clearly needed help getting applications to market faster by reducing the testing time.

In a very short time Ruby on Rails has gained popularity in the enterprise development community among both programmers and system managers. As an open source platform, Ruby is proving to offer a number of advantages for powering enterprise applications, not the least of which is a shorter development time for robust applications and the creation of denser code that's easy to work with and maintain. This article is offered as an introduction to Ruby on Rails for Java developers, offering some basic insight into the evolution of Ruby and Rails and its expanding role in enterprise application development.

Many articles have already been written about service-oriented architecture (SOA) and Service Component Architecture (SCA), for example, see references [1] and [2]. In this article we'll focus on a freely available, open source implementation of the Service Component Architecture that provides a simple way to implement SOA solutions. This SCA implementation is being developed in the Apache Tuscany Incubator project. The project started in 2006 and is being used by many who are looking for a simple SOA infrastructure. The recent Tuscany SCA version 1.0, which was released in September 2007, supports the Service Component Architecture specifications 1.0.

Maven is a promising application development lifecycle management framework coming from Apache's armory of open source tools. Maven was originally developed as a framework to manage and mitigate the complexities of building the Jakarta Turbine project and soon became a core entity of the Apache Software Foundation project.

The hope of using any persistence framework is absolute database independence. Database independence means that you can focus on your job as an application developer and not a DBA. However, no framework can fully make this claim. There's much more to running an application on a database than simply issuing compatible SQL queries and getting back the query results as expected. In my last article, I detailed the process by which we converted existing Enterprise Java Beans 2 (EJB2) Entity beans to Hibernate Plain Old Java Objects (POJOs). This article is less about our conversion process and more about the tools and methods we chose to work with for the Hibernate implementation and the backend databases (Oracle and PostgreSQL) supported by Hyperic HQ.

The Jedi mind trick is a Force power that can influence the actions of weak-minded sentient beings. Vendors will often try to apply the Jedi mind trick in selling silver-bullet software solutions that solve global warming and stop celebrity feuding while enabling service-based architecture development. Let's quickly put on our aluminum foil caps and repel the Jedi mind trick by turning to open source solutions. Service-based architectures are being touted as the next step in reaching programming nirvana. With these marching orders it's often difficult to build a framework that allows for simple service creation. This framework should also be flexible, scalable, and lightweight as well as easy in exposing services externally.

Until recently, tuning IT application performance has been largely a guessing game. This is both surprising and unacceptable considering the relentless focus IT organizations put on cost-efficiency and productivity. The traditional approaches to database and application tuning that involve collecting large volumes of statistics and making trial-and-error changes are still in widespread use. Today, most server management and monitoring tools deliver 'server-oriented' statistics that don't translate to concrete end-user benefits.

In order to describe itself as an 'open source' company, need a company merely be 'a company that will help you make the switch to open source in your company' - or does it have to be one that lets users feely download, compile, and use the software in question? Where is the dividing line? How open is 'open'? At Enterprise Open Source Magazine we contacted a range of FOSS luminaries for their take on the issue.

The significance of blogging is not the word 'blog' whether used as a verb or a noun, but its role as a harbinger of the game-changing Web-as-platform revolution. In particular, the migration of blogging from the individual toward the enterprise...

Even for many seasoned developers, Swing code can be notoriously difficult to organize. Where is the right place to put parsing and validation logic? How do you prevent those threading issues that cause lockups or repainting glitches? Is it possible to unit test GUI logic? Can the code somehow be shared with other user-interfaces, like a web front-end? If these questions sound familiar, the solutions presented here may revolutionize the way you code with Swing.

In our previous article - 'Rich Internet Components with JavaServer Faces' (JDJ, Vol. 10, issue 11) - we discussed how JavaServer Faces can fulfill new presentation requirements without sacrificing application developer productivity building Rich Internet Applications (RIA). We discussed how JSF component writers can utilize technologies, such as AJAX and Mozilla XUL, to provide application developers with rich, interactive, and reusable components.

The client/server development model prevalent in the mid-1990's resulted in extremely easy-to-build rich GUI applications that interacted directly with a relational database. 4GL tools such as Visual Basic and PowerBuilder let even junior developers visually compose both the presentation and most of the backend data binding. While this made for impressive Rapid Application Development (RAD) productivity, the client/server architecture was severely challenged when dealing with real-time environments where the data changes rapidly and applications require visibility to the correct data at all times. As a result, client applications were forced to poll the database continuously to check for changes.

After getting a head of gray hairs and a quickly receding hairline, I have learned that the simplest solutions are often the best. Having worked with Java since 1995 and various software development lifecycle methodologies over the years, I have seen things grow complex in these areas. Thanks to some new lighter-weight Java tools and agile methods, I can provide a fresh perspective on developing Java applications in an agile manner.

Enterprise Rich Internet Applications (RIAs) are the next evolution of business application development. There are four different approaches to RIA development - AJAX, Java, Flash, and .NET - and many different RIA solutions available today. This article answers the following questions: What are enterprise RIAs? Which approach should you use? Which solutions are appropriate for you? And how are RIAs being adopted today?

'All the big announcements have been made. I'm the warm-up act for James Gosling,' quipped former Sun CEO Scott McNealy on the final day of JavaOne 2006 in San Francisco. 'This is what post-CEO life is like!' he added, wryly, as he announced the winner of 'Bike to Work Week.' But he was still able, wholly justifiably, to bask in the reflected glory that is Java. And so he did, with complete humility and with his customary zeal and zest for helping the technology future arrive more quickly apparently undiminished.

Every action has an equal and opposite reaction, according to the third of Sir Isaac Newton's laws of physics: if you push on anything, it pushes back on you. That's why if you lean against the wall, you don't just fall through it, and that's also why ESR's Open Letter to Scott McNealy - published here on Monday - is producing a welter of counter-opinions.

A couple of years ago I began developing in Java, and my first Java project required that I also learn SQL. Our project team was using mostly EJBs for database access, although for some performance-critical sections of the application we wrote the JDBC logic directly. A problem that we faced regularly was tracking the bind parameters to our PreparedStatements. Over the course of the project, all of the team members tried different techniques to determine what our JDBC statements were actually doing.

In our last article - 'JSF and AJAX' (JDJ, Vol. 11, issue 1) - we discussed how JavaServer Faces component writers can take advantage of the new Weblets Open Source project (http://weblets.d ev.java.net) to serve resources such as JavaScript libraries, icons, and CSS files directly from a Java Archive (JAR) without impacting the application developer.

The novel A Deepness in the Sky by Vernor Vinge is set in the distant future. The character Pham Nuwen is responsible for maintaining software whose components are thousands of years old. Today, however, it's difficult to imagine maintaining an Enterprise Java application for more than a few years. More often than not, the application is tightly coupled to infrastructure frameworks that evolve rapidly in ways that don't preserve backwards compatibility. Consequently, upgrading to a new and improved framework can be challenging and risky.

Which platform to use Java or .NET? Developers ask this question all the time. Java has been widely adopted because of its overwhelming benefits on the server side, but Java has less to offer on the client side. .NET has made inroads into the enterprise by leveraging its stronger rich-client capabilities. An alternative solution for enterprise-scale Internet application development is the emerging XML-based rich-client technology.

'We've seen the Web moving from a publishing paradigm to an e-business paradigm to an AJAX paradigm.' That is the considered verdict of IBM Software Group's CTO of Emerging Internet Technologies, David Boloker. And he's right: AJAX is here, it's growing, and it's (potentially) the biggest thing to hit the i-Technology world since Java.

Yakov shows that working with the streams over the Internet may be as simple as dealing with files on your local disk, in the sixth installment of Java Basics.

One day my son Dave (10) showed up in my office with my rated 'R' Java tutorial in his hands. He asked me to teach him programming so he could create computer games. By that time I've already written a couple of Java books and have taught multiple classes on programming, but all of this was for grownups! A search on Amazon could not offer anything but books for dummies! After spending hours on the Internet, I could only find either some poor attempts to create Java courses for kids, or some reader-rabbit-style books on our friends computers.

Yakov Fain's popular online tutorial series continues. This lesson he discusses the basics of threads, including how to create them, how to get them to step aside, and how to stop them.

Yakov Fain, in Lesson 9 of his immensely popular online 'Java Basics' series for JDJ Industry Newsletter, talks about using threads for creating more advanced programs than those already discussed in Lesson 8. He analyzes the role they play in major Internet portals like Yahoo, CNN, or your bank's Web site. These portals usually display different types of information like News, Weather, Stock Market quotes, etc. Each of these info pieces appears on the screen instantaneously even though it's coming to the portal from different servers.

The marketplace tells you that 'middleware is everywhere' when all along it should wise up and recognize that 'middleware is dead.' Because that's the new reality of enterprise computing today, according to Sun's software czar Jonathan Schwartz.

In this month's article I introduce TableLayout, a robust but easy-to-use LayoutManager for use in any Java Swing application. It's based very loosely on the HTML TABLE paradigm, where components are placed in table cells in row-major order. Vertical and horizontal alignment for the component in a cell can be specified, and a component (cell) may span rows and columns. I also present Forms-Panel, a JPanel sub-class that abstracts the underlying TableLayout.

The publicity that AJAX grabbed over the last half a year is based on closing the gap between the Web applications and the desktop applications, combining the 'reach' and 'rich.' At the same time, the gap between the technological level of AJAX and what corporate developers expect in their modern arsenal is really astonishing. After all, AJAX is neither a tool nor a platform. There is no AJAX standards committee or community process in place. While software vendors are crafting proprietary development platforms on top of AJAX - which pretty much means 'from scratch' - early adopters of AJAX are left on their own.

Developers using Java on clients or in small projects may not believe that there is a fundamental problem with Java's robustness. People working with huge applications and application servers written in Java know about the problem but may doubt that it's possible to build something like an unbreakable Java architecture.

When speaking of Web application development today, it's difficult to ignore the overwhelming influence of the Portlet Specification (JSR-168). Even before the specification was formally finalized by the expert group, the Java world saw older CMS application implementing it and new portal software arrivals in the market. The proverbial 'gold rush' to develop new applications as portlets, refactor existing applications to comply with the specification, and deploy new Web sites on portal software is not without good reason. The Java community was lacking a unifying specification in the Web tier, where all previous work could be brought together and leveraged, removing the tedious tasks developers once had to endure when creating most common Web applications.

In the past few years there has been a proliferation of frameworks that allow for lighter, faster, and loosely coupled Java projects. These frameworks not only let you decouple your Java project from the application server for unit testing, they also allow for more agile refactoring, testing, and design techniques. This article will focus on telling the story of a large-scale refactoring effort implementing Spring and Hibernate as the underlying infrastructure tools. For those living under an abacus Spring is a J2EE framework built to handle many of the plumbing issues on a typical J2EE application. Hibernate is a popular Open Source Java object/relational persistence framework.

Various events may happen to a running program: a user clicks on a button in a window, the Web browser decides to re-paint the window, and so on. I'm sure, you've tried to click on the buttons of the calculator from the lesson on Swing Basics, but these buttons were not ready to respond to your actions yet. This time, let's teach window components to react on such actions.

Aspect-Oriented Programming (AOP) is undeniably one of the coolest things to happen in the software technology in a long time. AOP has been called the 'third dimension of programming' (copyright by Frank Sauer, Technical Resource Connection, Inc.) and has tremendous power in dynamically inserting logic into pre-existing programs. It can help solve some of the key problems (technology gaps, so to speak) still facing IT organizations. More specifically, AOP is now beginning to bridge the gap in three areas of software technology.