JavaServer Pages is a hot technology right now, as all Java developers are aware. In its simplest explanation, JSP provides the ability to combine Java code with HTML content to achieve dynamic content output from a single source file. Behind the scenes the JSP is compiled into a Java servlet that can be run in any compliant Java servlet engine/container. In essence, a JSP is a way to dynamically create a servlet with a large amount of HTML output and some Java code/logic. So instead of putting a large number of out.println(''); statements in a servlet with very little logic, a developer can simply create a JSP page containing standard HTML and a little logic. The JSP compiler will compile the page into a servlet, handling all the ugliness of those out.println() statements.

Extremely large, complex software systems stretch the limits of modern design and implementation techniques. Agent-based computing is an approach to design and implementation that facilitates the design and development of sophisticated systems by viewing them as a society of independent communicating agents working together to meet the goals of the system. Java programming language's rich support for networking, security, and introspection make it well suited to implementing a distributed agent-based computing system.

Sometimes it's worthwhile to go back and visit your former projects. It certainly was for me - using presentation as a commodity to be deployed according to network configuration is the concept that resulted from my visit.

The term deploy describes the process of installing the pieces of an application to a host and making whatever modifications are required to the host environment so the application runs correctly without further modifications. A patch is a group of Java class files, one or more documentation files, and one or more batch files that installs them to modify the behavior of a deployed program.

The Java 2 Platform, Standard Edition (J2SE technology) v1.3 for Linux means that Linux users and developers can take advantage of thousands of Java technology-based applications, from enterprise e-commerce infrastructure to client-side applications. It also opens up a huge emerging market for companies that already develop Java products.

The world is abuzz with the promise of embedded systems, and hopes are riding high on the immensely popular Linux operating system. Its open-source model, easy customization, and popularity with developers make it an ideal choice for embedded systems. The recent flurry of Linux-powered devices on the market boggles the mind:

Linux from its inception was written by programmers for programmers. In the years since, the GUI interfaces and other user-friendly items have raised the warm and fuzzy quotient to make Linux accessible to the casual user. However, the core idea remains: provide maximum support and usability to the people who make the software happen. That commitment continues; after all, the people who make Linux grow, the ones responsible for its tremendous success, are almost all programmers - techies! - and as such, are interested in better tools first; the nifty toys to be built with those tools are 'a trivial excercise left to the student.'

If you think Linux is the choice of geeks only, think again. Many of the large software vendors are now shipping Linux versions of their software. In this article I'll take you through some of these product offerings. Be prepared, though: if you're new to this Linux world you're going to find some interesting facts. The majority of vendors are bringing their wares to this new and exciting platform.

Numerous books and publications are available on the various technologies that support e-commerce on the Internet. As Java Servlets and JavaServer Pages (JSPs) emerge as a popular technology, a lot of material is being written about them. Most of this material focuses on programming model features, ease-of-development issues, and integration with tools. However, Web site developers are increasingly concerned about developing sites that can scale to a large number of hits while keeping the complexity of the software at a reasonable level.

All major and minor application server vendors heavily advertise the connection pooling functionality of their respective offerings. In this article I examine what's involved in developing resource pooling features from the perspective of a Java developer. I feel the subject is both greatly overhyped and underrepresented in technical literature.

During our last project we needed a logger but didn't want to develop our own, so we looked for third-party logging APIs. We found a few and experimented; one of them, log4j, far outshone the others. It helped us so much in tracing and debugging our problems that we recommended it for other projects, where it also got rave reviews.

To extend Java's concurrent behavior in a more natural way, in a more object-oriented point of view, we propose an extension to Java's concurrency model that will emulate Eiffel's separate statement. (Eiffel is an object-oriented language with a comprehensive approach to software construction.) The extension permits the attachment of nonphysical processors or threads to objects, thus allowing them to behave in an asynchronous and completely independent manner. This article briefly shows the concurrency tools of the Java programming language, points out their shortcomings, proposes solutions, and ends with the implementation of a solution.

Given the popularity of the Java software application development platform and the market potential for embedded devices, there's a need to understand how programs can take advantage of the use of Java for embedded application development. This article investigates three Java tools that are available for the embedded engineer and analyzes how well they map to the needs of the embedded community.

Serialization in Java is an operation in which an object's internal state is translated into a stream of bytes. This binary stream or image of the object is created in an operating system-neutral network byte order. The image can be written to a disk, stored in memory, or sent over a network to a different operating system. This amazing feat requires little or no work on the part of the programmer. Just implement the serializable interface, which contains no methods, and call the writeObject() method on your object, and it's serialized! You can serialize an object to or from any I/O device that Java supports.

Most application architectures are organized into tiers. Presentation, business logic, and data combine to form a complete solution from end to end. The data tier is where your application gets and stores data that's used throughout the application. It could be accessing relational- or object-oriented databases or native file stores or connecting to a mainframe to obtain its data.

The design of the Java language has done much to overcome the limitations of C and C++. However, testing and debugging continue to account for much of the cost of developing Java applications. Once you've deployed a Java application, it's even more difficult and costly to fix software faults.

One of the problems of highly distributed systems is figuring out how systems discover each other. After all, the whole point of having systems distributed is to allow flexible and perhaps even dynamic configurations to maximize system performance and availability. How do these distributed components of one system or multiple systems discover each other? And once they're discovered how do we allow enough flexibility, such as rediscovery, to allow their fail-safe operation?

Server-side Java continues to gain ground as the technology of choice for powering dynamic Web sites, but the goal of using Java to separate presentation from business logic has been a tough one to achieve.

There are many concerns surrounding the security of Java applets and applications downloaded from the Internet. But because Java developers placed a lot of importance on security from the start, Java is the preferred technology for use in networked environments. When Java's security features are implemented properly, Java programs are safe and can be downloaded to your computer without any security risk.

Imagine this scenario: you've written all the appropriate interfaces and implementations for an EJB and now it's time to use it in client code. First you get a bean reference. Everything is simple enough: use JNDI to get the home interface, call a create method on it and catch all the possible exceptions. Voilá, a usable EJB reference. No big deal. However, after creating the bean and looking at the number of beans you want to use, you realize you'll be doing the same thing over and over again. You shake your head and say, 'There has to be a better way to create these objects.'

On the Web it's about three things – speed, reliability and scalability. Does your Web site respond quickly? Does your Web site always respond quickly? Does your Web site always respond quickly when it's being used by tens or hundreds of thousands of users?

Popup menus, the extremely functional components available to the Java developer, allow developers to provide menu capability without the inclusion of a full-blown menu system (i.e., MenuBar, Menus). From a user interface perspective, however, they're not intuitively accessible. The popup menu is usually triggered by pressing the right mouse button, but users may not be aware of its availability.

The Oracle Internet Platform embeds the Oracle8i JVM within the Oracle8i database and Oracle Internet Application Server (iAS) as the enterprise Java engine for Oracle. This article explains Oracle8i JVM's base architecture, its support for J2EE APIs and its latest performance and architecture enhancements.

Increasingly, business applications are evolving into a client side that interacts with the user, and a server side that stores and retrieves data and manipulates it in various ways. The client side may run on a number of different hardware types including telephones, pagers and handhelds, in addition to the usual assortment of desktop and laptop computers. The intricacies of dealing with this assortment of client types from a single server would make a good article but will have to wait for another issue, because our subject today is the server side.

JavaSpaces is a powerful Jini service specification from Sun Microsystems that provides a simple yet powerful infrastructure for building distributed applications. The JavaSpaces specification defines a reliable distributed repository for objects, along with support for distributed transactions, events and leasing. In the JavaSpaces programming model, applications are viewed as a group of processes, cooperating via the flow of objects into and out of 'spaces.'

Two basic types of data - test and binary - are used in applications to create files such as documents, images, video, text and executables. Certain applications, however, may need to alter a file to make it available to other applications; for example, e-mail requires text and binary data to be encoded before it's sent.

Building large systems requires the difficult and time-consuming activities of elicitation and representation of software requirements. During these analysis activities, particular analysis abstractions emerge. These abstractions, called analysis patterns, represent reusable patterns for subsequent analysis efforts in various domains. As an example, software developers use an analysis abstraction called Person to represent a person from different application domains, such as a student person, employer person or customer person. Martin Fowler, in his book Analysis Patterns, has defined a higher abstraction to represent either a person or an organization labeled the Party pattern.

The Web is moving to wireless and Java is making it happen! How is a wireless environment different from the Web? What languages are used for wireless devices and what features do they have? Most important, what role does the Java 2 Enterprise Edition (J2EE) play in a wireless architecture?

In just a few years the Java language and platform has become the technical approach of choice for building complex, distributed and Web-enabled applications across the enterprise. Thanks to its cross-platform runtime environment, object-oriented development model, and facilities for working with object request brokers and other code components, Java is well equipped for building such applications.

Several fun and important secrets of SQLJ will be unlocked today. Our show will include the following numbers: Some magic tricks for taming the SQLJ translator to do your bidding. Some incantations to turn you into a SQLJ debug-mon. An initiation to the mysteries of execution contexts - for getting full control over executing SQL statements - and of connection contexts. A happy story of brotherly love between JDBC and SQLJ. A map of the hidden location containing all of the remaining SQLJ details that the wonderful folks from Java Developer's Journal neither would or could let me fit into this column.

The Java 2 Platform, Enterprise Edition (J2EE), especially its Enterprise JavaBeans technology, provides an industry standard for the development of distributed enterprise applications. EJB helps solve a major problem: providing distributed access to persistent data. But it doesn't solve a related problem: modeling the business processes that applications use to access and manipulate that data.

During the last couple of years there have been several developments in the application server environment. Nineteen ninety-nine truly was the 'Year of the Application Server.' The evolution of the application server market has been influenced by several factors. The term application server almost always refers to Java application servers (Microsoft's MTS and COM+ notwithstanding), i.e., application servers based on the J2EE platform.

Yes, Virginia, there are still people who think you can build a complex B2B e-commerce Web site using HTML. The good news is, these people are mostly harmless; they'll learn the error of their ways quickly and probably before their projects are too far down the road. There are far more insidious and dangerous misconceptions out there in the IT world regarding e-business systems.

Polymorphism is an often-misunderstood concept within the developer community. Outside the community it's often a buzzword used to create an image of intellectual capital accumulating in a vault somewhere.

Enterprise system developers have embraced the Java 2 Platform, Enterprise Edition (J2EE) development model and the collection of Java APIs for developing standard, component-based, multitiered enterprise solutions. These APIs provide a standard mechanism for accessing pertinent system services typically required for enterprise systems development such as databases (JDBC), asynchronous communication (JMS), transaction support (JTA), e-mail (JavaMail/JAF), distributed computing (RMI/IIOP), naming and directory services (JNDI) and Web client presentation (servlets/JSP). Enterprise JavaBeans (EJB) is a core J2EE API that provides for a standard server-side component model.

Part 1 of this series on business rule engines (see 'Implementing Business Rules in Java,' JDJ, Vol. 5, issue 5 [May 2000]) addressed the question of how to integrate the rule engine into a Java application. To review...business rules are the policies and procedures that describe or constrain the way an organization conducts business.

Front-end architecture and the art of developing GUIs that are functional and intuitive have been a challenge in this industry for quite some time. The advent of Java has made things a little easier; Java's extensive Swing package has assisted in the rapid creation of GUIs for application development. While the package provides a vast array of robust graphical widgets, there comes a point when a developer will stretch the limits of the component by attempting to provide functionality that is either not supported or nonexistent. JFileChooser is an example of one such component. The purpose of this article is to provide the reader with the knowledge and understanding to extend JFileChooser's functionality in order to display information from a generic directory service.

They usually happen during the early hours of the morning, shortly before the code needs to ship: exception errors. . . .

Have you ever wanted to have your own Web e-mail system, rather than relying on free Web e-mail services? In this article I'll show you how to build a scalable Web e-mail system based on Java servlets and JavaMail, two members of the Java 2 Enterprise Edition (J2EE) platform. The system provides a thin, HTML-based e-mail client that will enable you to access your own e-mail account from any Web browser, anywhere in the world.

The past three articles in this series have highlighted the strengths of scripting languages. They're interactive and dynamic, and allow you to experiment, debug and prototype solutions quickly. However, the most common response when I speak to die-hard Java fanatics is, 'Yeah, but I'll have to learn another language and I already know Java' (I consider myself a die-hard Java fanatic to a degree).