 |
|
|
|
|
|
Unicode and software internationalization
Unicode is a powerful technology for enabling international applications, but it doesn't solve all problems by itself. You need to think carefully about where your data is going and how you are processing text in order to use Unicode to build a successful international application.
|
|
Articles |
|
01 Apr 2000 |
|
| |
JMS, XML, and the heterogeneous enterprise
Most computing environments today are characterized more by a patchwork of different platforms than by an adherence to any one platform. The Java Message Service (JMS), together with the Extensible Markup Language (XML), extends the promise of integration to this heterogeneous environment. This article demonstrates how to use JMS to create and distribute XML-based messages to Java and non-Java applications alike.
|
|
Articles |
|
02 May 2000 |
|
| |
Servlets and XML: Made for each other
Find out how Java servlets and XML work together to generate an XML document and DOM tree and interface with a database. This article includes a couple of useful techniques: using HTTP parameters to control processing and generating a DOM tree without an XML source document.
|
|
Articles |
|
02 May 2000 |
|
| |
Java accessor visibility
This article gives guidance on the visibility of accessor methods. It is modified from Chapter 8 of The Object Primer 2nd Edition.
|
|
Articles |
|
01 Oct 2000 |
|
| |
Web services programming tips and tricks: Is Enterprise JavaBeans (EJB) technology for you?
Although EJB technology is one of the leading platforms, along with DCOM and CORBA, for the development of mission-critical applications, it isn't the best fit for every project. This tip describes the factors that you want to consider when determining whether EJB technology is the right option for you.
|
|
Articles |
|
09 Nov 2000 |
|
| |
Web services programming tips and tricks: Legacy integration techniques for Java applications
You can easily integrate your Java, J2EE, and EJB-based applications with existing legacy systems following one or more of the four common integration strategies described here.
|
|
Articles |
|
16 Nov 2000 |
|
| |
Connection pools
Connection pooling is a technique used for sharing server resources among requesting clients. This article focuses on support for connection pooling of both database resources and non-database resources in a J2EE environment. Siva examines the JDBC 2.0, JMS 1.02, JNDI 1.2 Standard Extension APIs with regard to connection pooling and looks at some existing vendor implementations of those APIs. He then looks at the upcoming J2EE Connector Architecture 1.0 that would support a vendor-independent/pluggable approach to managing resource connections.
|
|
Articles |
|
21 Nov 2000 |
|
| |
Developing in the real world
The team that developed IBM WebSphere Host Publisher is made up of developers who had lots of C and C++ experience, but not much Java programming experience. When they decided to develop version 2.1 using Java technology and XML, the developers had to climb the learning curve fast -- and get their product out the door.
|
|
Articles |
|
01 Jan 2001 |
|
| |
Web services programming tips and tricks: UML sequence diagramming with style
Try these tips for creating effective UML sequence diagrams. This article was adapted from Chapter 6 of The Object Primer 2nd Edition.
|
|
Articles |
|
01 Feb 2001 |
|
| |
Bug patterns: An introduction
This premier article introduces the notion of bug patterns, an extremely useful concept that will increase your ability to detect and remedy bugs in your code.
|
|
Articles |
|
01 Feb 2001 |
|
| |
Writing multithreaded Java applications
The Java Thread API allows programmers to write applications that can take advantage of multiple processors and perform background tasks while still retaining the interactive feel that users require. Alex Roetter introduces the Java Thread API, outlines issues involved in multithreading, and offers solutions to common problems.
|
|
Articles |
|
01 Feb 2001 |
|
| |
Handling memory leaks in Java programs
Memory leaks in Java programs? Absolutely. Contrary to popular belief, memory management is still a consideration in Java programming. In this article, you'll learn what causes Java memory leaks and when these leaks should be of concern. You'll also get a quick hands-on lesson for tackling leaks in your own projects.
|
|
Articles |
|
01 Feb 2001 |
|
| |
Struts, an open-source MVC implementation
This article introduces Struts, a Model-View-Controller implementation that uses servlets and JavaServer Pages (JSP) technology. Struts can help you control change in your Web project and promote specialization. Even if you never implement a system with Struts, you may get some ideas for your future servlets and JSP page implementation.
|
|
Articles |
|
01 Feb 2001 |
|
| |
Portable database reporting using Java and XML
This article explains how to generate printable reports from a database using Java- and XML-related technologies like Xalan, Xerces, and FOP. It demonstrates how Java and XML make it possible to develop reporting tools that work under different operating systems using the same source code.
|
|
Articles |
|
01 Feb 2001 |
|
| |
Unicode fundamentals
This tutorial is for anyone who wants to understand the basics of Unicode-based multilingual Web page development.
|
|
Tutorials |
|
16 Feb 2001 |
|
| |
Testing, fun? Really?
Testing. Yuck! Puh! Aagh! I've always hated testing. Testing, both unit and functional, is something that gets in the way of the "real" work. Everyone knows that their code is perfect, right? In the unlikely event that the code does need to change, the comments are so well written that anyone could figure it out. Wow, am I in need of growth (maybe some counseling as well.
|
|
Articles |
|
01 Mar 2001 |
|
| |
XP distilled
Object-oriented programming using the Java language has become immensely popular. It has revolutionized software development to some degree, but recent studies show that half of software development projects are late, and one-third are over budget. The problem isn't the technology; it's the way we develop software. So-called "lightweight" or "agile" approaches, coupled with the power and flexibility of object-oriented languages like the Java language, offer an intriguing solution. The most popular agile approach is called Extreme Programming, or XP, but many people don't really know what it is. Using XP on your Java projects can increase your chances of success dramatically. This article provides an overview of XP and explains why it is important -- without the rumor or the hype.
|
|
Articles |
|
01 Mar 2001 |
|
| |
Diagnosing Java Code: The Null Flag bug pattern
Often, our efforts to develop robust programs by substituting null pointers for exceptional conditions actually limits control flow to the ordinary paths of method invocation and return, and buries evidence of where an exceptional condition occured. In this column, Eric Allen shows how this bug pattern, which he calls the Null Flag bug pattern, produces unexpected results that are difficult to debug. As with the other bug patterns that we have discussed, you can minimize occurrences of this pattern by applying certain programming techniques.
|
|
Articles |
|
01 Mar 2001 |
|
| |
Diagnosing Java Code: The Dangling Composite bug pattern
One of the most commonly recurring (and most complained about) bugs in Java programming is the null-pointer exception. Tracking down the cause of one of these bugs can truly make you question your career decision. In this installment of Diagnosing Java Code, we'll continue with our examination of bug patterns by cataloging one of the most common patterns associated with null-pointer exceptions and step through an example of a class that contains it. We will then review several programming techniques that can help you minimize the pattern's occurrence.
|
|
Articles |
|
01 Mar 2001 |
|
| |
Web services programming tips and tricks: Implementing many-to-many object relationships
In Java, a many-to-many object relationship is implemented via a combination of collections and operations to manipulate those collections.
|
|
Articles |
|
15 Mar 2001 |
|
| |
Diagnosing Java code: The Double Descent bug pattern
Although usually easier to debug than other, more insidious erroneous behaviors, class-casting error messages are often symptoms of conceptual errors in recursively descending a composite data structure. In this installment of Diagnosing Java Code, Eric Allen discusses where programmers should look to find this pattern of bug, how to recognize the pattern, and what they can do to minimize its occurrence.
|
|
Articles |
|
01 Apr 2001 |
|
| |
Build your own Java-based supercomputer
If you've ever wanted to build your own supercomputer but have been held back by the demands of parallel programming in C, Pseudo Remote Threads is for you. This prize-winning Java programming model greatly simplifies parallel programming on clusters, bringing supercomputing out of the laboratory and into the hands of everyday Java programmers.
|
|
Articles |
|
01 Apr 2001 |
|
| |
Java Collections Framework
This tutorial takes you on an extended tour of the Java Collections Framework, introduced with the Java 2 platform, which provides a well-designed set of interfaces and classes for storing and manipulating groups of data. Author and consultant John Zukowski expertly teaches you how to use the concrete collection implementations, how to apply sorting and searching through collections, and how to use read-only and thread-safe collections. A complete set of exercises follows the tutorial to let you test your knowledge.
|
|
Tutorials |
|
10 Apr 2001 |
|
| |
Diagnosing Java Code: The Liar View bug pattern
GUIs are generally designed with a model-view-controller architecture in which the view is decoupled from the model. The separation presents a challenge to automated testing because it's difficult to verify that a state change in the model is reflected appropriately in the view -- it spawns the infamous "Liar View." This installment of Diagnosing Java Code examines the Liar View bug pattern.
|
|
Articles |
|
23 Apr 2001 |
|
| |
Understanding the Java ClassLoader
This free tutorial provides an overview of the Java ClassLoader and takes you through the construction of an example ClassLoader that automatically compiles your code before loading it. You'll learn exactly what a ClassLoader does and what you need to do to create your own.
|
|
Tutorials |
|
24 Apr 2001 |
|
| |
Diagnosing Java Code: The Saboteur Data bug pattern
When a program crashes due to corrupted data, the saboteur can be elusive. Often a program can crash dead in its tracks while manipulating its own internal data, even after working flawlessly for long periods. This article discusses a bug pattern that can be the culprit of this sort of crash, why it exists, and several methods to eliminate it -- before and after it occurs.
|
|
Articles |
|
01 May 2001 |
|
| |
The historical collection classes -- Arrays
From John Zukowski's recently published book, Java Collections, this excerpt (from Chapter 1) covers details about arrays -- what you can do with them and how to avoid pitfalls when using arrays.
|
|
Articles |
|
01 May 2001 |
|
| |
Simplify XML programming with JDOM
JDOM is a unique Java toolkit for working with XML, engineered to enable rapid development of XML applications. Its design embraces the Java language from syntax to semantics. But is it better than existing -- and more standard -- XML APIs? Judge for yourself as we run through some examples and illuminate the design goals of this popular open-source project, which recently was formally accepted as a Java Specification Request.
|
|
Articles |
|
01 May 2001 |
|
| |
Diagnosing Java Code: Improve the performance of your Java code
Many algorithms are expressed most concisely as tail-recursive methods. Compilers can automatically transform such methods into loops and thereby improve program performance, but this transformation is not required by the Java language specification, so not all JVMs will perform it. This means that tail-recursive methods in the Java language can result in unexpectedly large memory usage. In this article, Eric Allen demonstrates that dynamic compilation maintains the language's semantics while static compilation often doesn't. He shows why this matters and offers a bit of code to help you determine whether your just-in-time (JIT) compiler can transform tail recursion on code while preserving semantics.
|
|
Articles |
|
01 May 2001 |
|
| |
Diagnosing Java Code: The Broken Dispatch bug pattern
Method dispatch in an object-oriented language such as the Java language, in which methods can be overloaded and overridden, can cause difficulties of code management in even moderately complex programs. In this week's Diagnosing Java Code, Eric Allen discusses the bug pattern caused by these difficulties, outlining the symptoms when argument mismatches cause the wrong method to be invoked, and offering a few solutions to combat the problem.
|
|
Articles |
|
01 May 2001 |
|
| |
Java Modeling: A UML workbook, Part 1
In this first installment of his new column, Granville Miller introduces one of the building blocks of the Unified Modeling Language: sequence diagramming. Sequence diagrams are used throughout the design process to demonstrate the internal interactions between actors and objects as a system executes over time. Follow along with Granville as he creates one of these diagrams, using a loan processing application as his example.
|
|
Articles |
|
08 May 2001 |
|
| |
Build your own Java library
In this free tutorial, you will learn how the Java language can help you make a good, reusable library. The tutorial covers a few key principles of good library design and presents efficient ways to implement each. To illustrate the concepts, the tutorial walks through the design of a simple library.
|
|
Tutorials |
|
29 May 2001 |
|
| |
Securing Systems: A three-pronged solution for identifying users
The problem of system security starts with discovering the identity of the user on the other end of the communications link. In this article, Joseph Sinclair discusses three familiar approaches for identifying users, highlights their strengths and weaknesses (alone and in combinations), and provides some examples of each.
|
|
Articles |
|
01 Jun 2001 |
|
| |
Diagnosing Java Code: Recorders test for proper method invocation
In this installment of Diagnosing Java Code, Eric Allen describes how to use Recorders (a special type of Listener) in your unit tests to ensure that a sequence of method invocations occurs in the proper order.
|
|
Articles |
|
01 Jun 2001 |
|
| |
Using Inline in Perl
The new Inline module for Perl allows you to write code in other languages (like C, Python, Tcl, or Java) and toss it into Perl scripts with wild abandon.
|
|
Articles |
|
01 Jun 2001 |
|
| |
Java Modeling: A UML workbook, Part 2
Granville continues his discussion of the Unified Modeling Language and sequence diagramming. He examines the role of conditional logic in sequence diagramming and discusses why you might choose to include or exclude conditions and loops from a diagram. Granville also describes the two forms of sequence diagram -- generic and instance -- and explains their respective applications in the development cycle.
|
|
Articles |
|
05 Jun 2001 |
|
| |
Take command of your client/server apps
The Java programming environment offers several methods for you to implement client/server (C/S) conversational applications. This article describes a simple, lightweight approach that lets you exchange message objects between the client and the server.
|
|
Articles |
|
12 Jun 2001 |
|
| |
Java Modeling: Java Modeling: A UML workbook, Part 3
In this installment of Java Modeling, Granville leads you into the gray zone between modeling and method, with a look at requirements gathering via use case modeling. In particular, he focuses on the relationship between user interfaces, system interfaces, and use case descriptions. While tempting to do so, it is generally considered bad form to include user interface logic in a use case. Follow along as Granville uses sequence diagrams and system interfaces to show you why.
|
|
Articles |
|
26 Jun 2001 |
|
| |
Diagnosing Java Code: The Impostor Type bug pattern
In this installment of Diagnosing Java Code, Eric Allen examines the symptoms and causes of this bug, defines ways to prevent this error from occurring, and discusses a tempting hybrid implementation that does not use impostor types but, in the end, turns out to have many of the same weaknesses.
|
|
Articles |
|
01 Jul 2001 |
|
| |
Magic with Merlin: Long-term persistence
The ability to save the JavaBean component state for long-term persistence within an XML document has been a topic of much discussion with Java developers in the past few years. This feature has finally been adopted in the 1.4 version of J2SE. In this installment of Magic with Merlin, John Zukowski shows you how to use the new XMLEncoder and XMLDecoder classes, bypassing serialization and allowing you to generate fully initialized bean instances.
|
|
Articles |
|
01 Jul 2001 |
|
| |
Magic with Merlin: Just another plain Frame
Java 1.4 now allows you to remove a frame's title bar and programmatically maximize the frame. John Zukowski details and demonstrates these changes with this quick start and also shows how to support moving a frame without a draggable area.
|
|
Articles |
|
01 Jul 2001 |
|
| |
Diagnosing Java code: The Split Cleaner bug pattern
One of the features of the Java programming language is that storage is automatically managed, saving the programmer from the bug-prone task of freeing memory after it has been used. Nevertheless, many programs still have to manipulate resources, such as files and database connections, that must be explicitly freed after use. Like manual storage management, there are many pitfalls when managing resources in this way. One of these pitfalls is the topic of this week's column -- the Split Cleaner bug pattern.
|
|
Articles |
|
01 Jul 2001 |
|
| |
Magic with Merlin: Swing's new Spinner component
Welcome to Magic with Merlin, a bi-weekly series designed to give you a leg up on programming with Java 2 Standard Edition, version 1.4. Over the coming months, author John Zukowski will offer tips and tricks for navigating the wealth of new features in this release. In this installment, John describes the new JSpinner component of Swing, which allows you to choose dates, numbers, and selections from pick lists.
|
|
Articles |
|
01 Jul 2001 |
|
| |
WAP builds Java applications
If your company already relies on multitiered enterprise Java applications, then you may be closer to a wireless future than you think. By outlining a sample application, Aashish Patil shows you how to connect your existing enterprise Java infrastructure to a wireless netowrk with minimal investment in equipment and labor. Using existing EJBs, modified servlets, and new WML and WMLScript pages makes the process a snap.
|
|
Articles |
|
01 Jul 2001 |
|
| |
Quick-and-dirty Java programming
The Java language is a great high-level programming language, allowing us to stay close to the problem we want to solve while effortlessly experimenting with different solutions. But in the real world of everyday computing (and development), there are many situations where "whipping up a Java program" to perform a task is either impractical or too time consuming. This article takes you into the underground world of FESI (Free EcmaScript Interpreter), where deploying the Java language in a quick-and-dirty fashion is the norm rather than the exception.
|
|
Articles |
|
03 Jul 2001 |
|
| |
Threading lightly, Part 1: Synchronization is not the enemy
Unlike many other programming languages, the Java Language Specification included explicit support for threading and concurrency. While having language support for concurrency makes it easier to specify and manage constraints on shared data and the timing of operations across threads, it doesn't make the complexities of concurrent programming any easier to understand. This three-part series aims to help programmers understand some of the major issues behind multithreaded programming in the Java language, and in particular to understand the impact of thread safety on Java program performance.
|
|
Articles |
|
17 Jul 2001 |
|
| |
What's new in JDBC 3.0
The Java Database Connectivity (JDBC) API has emerged as a key part of the Java 2 Standard Edition (J2SE) and Java 2 Enterprise Edition (J2EE) platforms. It is the primary standards-based mechanism for the Java language to programmatically access relational databases, so when a new version of the specification is released by the Java Community Process, developers are bound to be interested. Here we summarize the key new features as outlined in Sun Microsystems' recently released Proposed Final Draft 3.0 of the JDBC specification.
|
|
Articles |
|
24 Jul 2001 |
|
| |
Diagnosing Java Code: The Fictitious Implementation bug pattern, Part 1
The Java language is free from many of the problems endemic to languages that support multiple inheritance -- in part because it restricts the specification of interface invariants to type signatures. But that restriction can combine with poor documentation to create problems: if you make incorrect assumptions about how an interface will be implemented, you may encounter frustrating bugs at run time. This article, first in a two-part series, outlines the development practices that can lead to such errors -- and ways to avoid them.
|
|
Articles |
|
31 Jul 2001 |
|
| |
Diagnosing Java Code: The Orphaned Thread bug pattern
In multithreaded code, it is often common to use a single, master thread that drives the actions the other threads take. This master thread may send messages, often by placing them on a queue, that are then processed by the other threads. But if the master thread throws an exception, the remaining threads may continue to run, awaiting more input to the queue, causing the program to freeze. In this installment of Diagnosing Java Code, full-time Java developer and part-time exterminator Eric Allen discusses detecting, fixing, and avoiding this bug pattern.
|
|
Articles |
|
01 Aug 2001 |
|
| |
An easy JDBC wrapper
JDBC provides a powerful, comprehensive interface for accessing databases from Java programs. For smaller projects, JDBC can seem overwhelming, driving some programmers to avoid using a database altogether. This article describes a simple wrapper library that makes basic database usage a snap. You'll find yourself wanting to use JDBC for every program you write.
|
|
Articles |
|
01 Aug 2001 |
|
| |
Magic with Merlin: Maintaining insertion order
Follow along with John Zukowski as he demonstrates how to iterate through the elements of a hashed collection in insertion order and how to maintain elements in access order with the new Collections Framework implementations in J2SE, version 1.4.
|
|
Articles |
|
01 Aug 2001 |
|
| |
Diagnosing Java Code: The Fictitious Implementation bug pattern, Part 2
In the last installment of Diagnosing Java Code, we saw that it is possible to implement a Java interface without actually meeting its intended semantics. This second article in a two-part series demonstrates two handy tools to fight such false implementation bugs. Eric Allen shows you how to use assertions and unit tests as executable documentation, making your code safer and more portable.
|
|
Articles |
|
14 Aug 2001 |
|
| |
Fundamentals of JavaMail API
Looking to incorporate mail facilities into your platform-independent Java solutions? Look no further than the JavaMail API, which offers a protocol-independent model for working with IMAP, POP, SMTP, MIME, and all those other Internet-related messaging protocols. With the help of the JavaBeans Activation Framework (JAF), your applications can now be mail-enabled through the JavaMail API.
|
|
Tutorials |
|
22 Aug 2001 |
|
| |
Java modeling: Holonic software development, Part 1
Granville Miller temporarily abandons the topic of requirements gathering for one more compelling: holonic software development. Find out how this method complements and extends the tenets of the agile development movement, and how its emergence into mainstream development circles may alter the education of software developers, as well as the practice of software development.
|
|
Articles |
|
28 Aug 2001 |
|
| |
Java sockets 101
This tutorial will teach you what sockets are and how to use them in your Java programs. Through several hands-on examples, ranging from single client/sever communication to a pooled collection of clients accessing the server, you will learn how to use sockets to handle typical scenarios that crop up in the real world.
|
|
Tutorials |
|
30 Aug 2001 |
|
| |
Magic with Merlin: Scrolling tabbed panes
Prior to the Merlin release of the Java platform, Swing's JTabbedPane control only allowed you to wrap tabs across multiple rows. The new and improved version of JTabbedPane lets you scroll the tabs across a single row. In this installment of Magic with Merlin, John Zukowski demonstrates how to change the layout policy of JTabbedPane and provides a complete example for you to use.
|
|
Articles |
|
01 Sep 2001 |
|
| |
Java Web Start
Java Web Start, a new technology to assist the development of client-side Java applications, frees you from concerning yourself with how the client is launched, either from a Web browser or from the desktop. Additionally, this technology provides an encompassing deployment scheme that enables a Web server to independently distribute and update client code. Software engineer Steve Kim introduces this enterprising new technology, scheduled to be integrated in the final release of Java 1.4.
|
|
Articles |
|
01 Sep 2001 |
|
| |
Diagnosing Java Code: Designing "testable" applications
In this installment of Diagnosing Java Code, Eric Allen takes a break from examining specific bug patterns and opts instead to discuss the issues involved in designing software that is easy, and even pleasurable, to test. He outlines seven design principles that can greatly increase your productivity in writing tests, and thereby improve the robustness of the resulting code base.
|
|
Articles |
|
01 Sep 2001 |
|
| |
Magic with Merlin: Porter-Duff rules!
Two-dimensional graphics programming with the Java language just got a little better. The AlphaComposite class, which previously supported only eight of the 12 Porter-Duff rules for digital image compositing, now supports all 12. In this installment of Magic with Merlin, John Zukowski describes all 12 rules and offers an interactive program to demonstrate how they operate.
|
|
Articles |
|
01 Sep 2001 |
|
| |
Threading lightly, Part 2: Reducing contention
In Part 1 of this series, we examined the performance overhead of uncontended synchronization. With each successive JVM version, overall performance has improved, and the cost of uncontended synchronization has been reduced, making the issue of uncontended synchronization overhead less significant. Contended synchronization, however, is quite expensive. This article will explore several techniques for reducing contention, and hence improving scalability, in your programs.
|
|
Articles |
|
05 Sep 2001 |
|
| |
Evaluate mathematical expressions quickly and accurately
Computer science's traditional methods for evaluating mathematical expressions are awkward and difficult for the untrained user; software engineer Nikola Stepan aims to change all that. His applet W3Eval evaluates expressions using the same sequence of steps you would on with a paper and pencil -- but with much faster and with no mistakes in arithmetic. Read on to learn about the challenges involved in transforming human-readable mathematics into Java code.
|
|
Articles |
|
10 Sep 2001 |
|
| |
Diagnosing Java Code: Designing extensible applications, Part 1
In this and several upcoming installments of Diagnosing Java Code, Eric Allen focuses his discussion on considerations involved in determining how extensible a new system should be, when extensibility is best applied, and how extensibility relates to other factors, particularly testability. In this first article, he examines the various ways in which a software system may be extensible and in what contexts each form of extensibility is most useful.
|
|
Articles |
|
25 Sep 2001 |
|
| |
Magic with Merlin: Working with preferences
The addition of the java.util.prefs package to Java 1.4 (through JSR 10) lets you manipulate user preference data and configuration data by providing you with access to an implementation-specific registry (for example, the Windows Registry on Windows platforms). In this installment of Magic with Merlin, John Zukowski introduces you to the Preferences class and walks you through its use. He puts it all together with a sample program.
|
|
Articles |
|
01 Oct 2001 |
|
| |
Java 2 gets a new focus subsystem
The Java 2 platform gets a completely new AWT focus subsystem with the latest release of Java Standard Edition, 1.4, and we've got the scoop on what makes it go. Java language engineer Bertrand Portier offers a first look at the new classes and methods (including the essential KeyboardFocusManager) that comprise the AWT focus subsystem, tips for adapting your programming efforts as you migrate to the new API, a working code example, and more.
|
|
Articles |
|
01 Oct 2001 |
|
| |
Threading lightly, Part 3: Sometimes it's best not to share
The ThreadLocal class appeared with little fanfare in version 1.2 of the Java platform. While ThreadLocal gets relatively little attention, it can be very handy for simplifying the development of thread-safe concurrent programs. In this third installment of Threading lightly, Java software consultant Brian Goetz examines ThreadLocal and offers tips for exploiting its power.
|
|
Articles |
|
16 Oct 2001 |
|
| |
Java Modeling: Holonic software development, Part 2
Granville Miller continues his discussion of holonic software development, with a conceptual overview of requirements gathering. Find out how the four most common requirements gathering processes -- features, user stories, use cases, and the traditional software requirements specification -- fit into the larger context of an agile software development process.
|
|
Articles |
|
23 Oct 2001 |
|
| |
Diagnosing Java code: Designing extensible applications, Part 2
Glass box extensibility refers to the ways in which a software system may be extended when the source code is available for viewing, but not for modifying -- it lies as the happy medium between black box design (in which extensions are built without viewing the original code) and open box design (extensions are coded directly into the base code). In this article, Eric Allen expands on the topic of glass box extensibility and offers some tips on how to implement it.
|
|
Articles |
|
23 Oct 2001 |
|
| |
Think small with J2ME
The Java 2 Platform, Micro Edition (J2ME) offers great tools for developers, porting the Java platform's network-centric and platform-agnostic worldview down to memory- and processor-limited devices. Soma Ghosh explains the basics of the J2ME world, showing you the building blocks of the platform and demonstrating a sample application.
|
|
Articles |
|
01 Nov 2001 |
|
| |
Java configuration with XML Schema
This article shows how to use a Java XML parser together with the Java language reflection features to create an arbitrary set of named objects according to the content of an XML file. Objects created by the proposed initialization process live in a hierarchical, global namespace. References to these objects anywhere in the code can be obtained by a simple query. The configuration-file XML schema discussed in this article is designed to specify the creation of "parameter objects" as instances of arbitrary Java classes.
|
|
Articles |
|
01 Nov 2001 |
|
| |
Working XML: Building a compiler for the SAX ContentHandler
This installment of the column describes the requirements for the Java project and analyzes its overall design. The new project, called HC (short for Handler Compiler), will take some drudgery out of event-based XML parsing by automatically generating the SAX ContentHandler for a list of XPaths.
|
|
Articles |
|
01 Nov 2001 |
|
| |
Working the Eclipse Platform
The Eclipse Platform provides an open universal framework for building developer tools. If you build tools or use tools, you will benefit from reading this article.
|
|
Articles |
|
01 Nov 2001 |
|
| |
Magic with Merlin: AWT roundup
Merlin makes several additions to the AWT library, including the ability to find the space used for screen adornments like the desktop toolbar, capitalizing Color constants, mouse wheel support, and the ability to differentiate between mouse and keyboard keys and locations better. Follow along with John Zukowski as he describes these changes and provides the nitty-gritty details to get you started fast.
|
|
Articles |
|
01 Nov 2001 |
|
| |
Managing database connections with JDBC
This tutorial introduces the different concepts involved in establishing and managing a database connection from within a Java application using Java Database Connection (JDBC). It is targeted primarily at developers who want to understand what is going on "under the hood" when using a database from within a Java application.
|
|
Tutorials |
|
13 Nov 2001 |
|
| |
Advanced database operations with JDBC
This tutorial introduces several advanced database operations, including stored procedures and advanced datatypes, that can be performed by a Java application using JDBC.
|
|
Tutorials |
|
19 Nov 2001 |
|
| |
Diagnosing Java code: Designing extensible applications, Part 3
Black box extensibility refers to the ways in which a software system may be extended when the source code is neither available for viewing nor for modifying. In this article, Eric Allen expands on the topic of black box extensibility, explains how extensions are made through system configuration or scripting languages, and offers some tips on how to implement black box extensibility.
|
|
Articles |
|
19 Nov 2001 |
|
| |
Java 3D joy ride
New to the world of 3D? This tutorial offers Java developers an introduction to the concepts involved with 3D programming in general and the Java 3D API in particular. IBM 3D software engineer and gamer at heart Suzy Deffeyes takes you on a joy ride through the world of Java 3D programming with a high-level discussion of the concepts involved and a detailed look at scene graphs -- the fundamental object used to describe the scene you want to render.
|
|
Tutorials |
|
29 Nov 2001 |
|
| |
Magic with Merlin: Exceptions and logging
The Merlin release adds several exception-handling-related features for understanding the root cause of a problem and responding appropriately. In this installment of Magic with Merlin, John Zukowski demonstrates how these new logging and exception features work and provides an example program for review and download.
|
|
Articles |
|
01 Dec 2001 |
|
| |
Diagnosing Java code: Designing extensible applications, Part 4
S-expressions are syntactic representations of lists of elements, delimited by parentheses. In this article, Eric Allen illustrates how S-expressions can be used to provide a useful and lightweight form of black box extensibility and also when they may be detrimental.
|
|
Articles |
|
11 Dec 2001 |
|
| |
Building Web-based applications with JDBC
If you're looking to build a Web application that interacts with a backend database using JDBC but you're not sure how, then this tutorial is for you. In this hands-on guide, you'll learn the fundamentals of this process using three separate techniques: a servlet approach, a JavaServer Pages (JSP) page approach, and combined JSP, JavaBeans, and servlet approach (also known as Model Two). Follow along with expert Robert Brunner as he steps you through each process and discusses the pros and cons of each.
|
|
Tutorials |
|
19 Dec 2001 |
|
| |
Working XML: Compiling the paths and automating tests
This month, our columnist discusses the compilation algorithm. He also invests a bit of time automating tests with JUnit.
|
|
Articles |
|
01 Jan 2002 |
|
| |
Improve modularity with aspect-oriented programming
Aspect-oriented programming (AOP) is a new programming technique that allows programmers to modularize crosscutting concerns (behavior that cuts across the typical divisions of responsibility, such as logging). AOP introduces aspects, which encapsulate behaviors that affect multiple classes into reusable modules. With the recent release of AspectJ by Xerox PARC, Java developers can now take advantage of the modularization AOP can provide. This article introduces AspectJ and illustrates the design benefits that result from its use.
|
|
Articles |
|
01 Jan 2002 |
|
| |
Diagnosing Java Code: Depth-first visitors and broken dispatches
Depth-first visitors, a variant on the Visitor pattern, may be used to increase the terseness of your code. In this article, Eric Allen describes the technique, discusses the advantages and the gotchas, cautions the reader about the bug patterns associated with its use, and illustrates depth-first visitors in the context of a specific example.
|
|
Articles |
|
01 Jan 2002 |
|
| |
Rock 'em, sock 'em Robocode!
Is it possible to learn inheritance, polymorphism, event handling, and inner classes, all while dodging bullets and executing precision attack maneuvers? A surprisingly addictive teaching-tool-turned-game-craze called Robocode is about to make this a reality for Java developers worldwide. Follow along as Sing Li disarms Robocode and starts you on your way to building your own customized lean, mean, fighting machine.
|
|
Articles |
|
01 Jan 2002 |
|
| |
Working XML: Compiling XPaths
This month our columnist describes how he implements the DFA construction algorithm, giving the first concrete example of using the compiler to recognize XPath.
|
|
Articles |
|
01 Jan 2002 |
|
| |
Java design patterns 101
Design patterns capture the experience of expert software developers and present common recurring problems, their solutions, and the consequences of those solutions in methodical way. This tutorial explains why patterns are useful and important for object-oriented design and development, and how patterns are documented, categorized, and cataloged. It also discusses when patterns should be used and provides examples of important patterns and how they are implemented.
|
|
Tutorials |
|
08 Jan 2002 |
|
| |
Get the message?
This article outlines how to use Java Messaging System (JMS) for large-scale file replication. Dan Drasin describes a solution to an Applied Reasoning customer's distributed data problems, and provides implementation details for a JMS-based solution. He discusses the advantages, some potential pitfalls, and practical instructions for successfully setting up IBM MQSeries (now called WebSphere MQ) as a JMS server.
|
|
Articles |
|
01 Feb 2002 |
|
| |
Implementing vendor-independent JMS solutions
The popularity of the Java Message Service has been on an upswing lately, perhaps bolstered by the support of several major players in the world of real-time messaging. As an increasing number of vendors jump on the JMS bandwagon, it makes sense to ensure that your JMS code will work unmodified across multiple proprietary implementations. With a few simple steps, Java architect Nicholas Whitehead shows you how to combine JMS, the Java Naming and Directory Interface, and a well-made properties file to build vendor-neutral JMS solutions.
|
|
Articles |
|
01 Feb 2002 |
|
| |
XML and Java technologies: Java document model usage
In this article, XML tool watcher Dennis Sosnoski compares the usability of several Java document models. It's not always clear what the tradeoffs are when you choose a model, and it can require extensive recoding to switch if you later change your mind. Combining sample code with analysis of the model APIs, the author gives recommendations for which models may really make your job easier. Includes code samples that show the methods for the five different document models.
|
|
Articles |
|
01 Feb 2002 |
|
| |
Java theory and practice: Should you use JMS in your next enterprise application?
Welcome to Java theory and practice, a new monthly column by veteran Java developer Brian Goetz. This column aims to explore that elusive juncture where design principles meet the requirements to solve real-world problems. Each month, we'll explore design patterns, principles of reliable software design, and why best practices are best, with an eye to how they are applied to real problems. This month, Brian takes a look at enterprise message queuing technology.
|
|
Articles |
|
01 Feb 2002 |
|
| |
Magic with Merlin: Working with assertions
Merlin adds the ability to provide optional pre- and post-condition validation to methods for improved testing. Although the assertions facility is disabled by default at run time, it can be enabled to check error conditions. In this edition of Magic with Merlin, John Zukowski walks you through the basics of adding assertion checking to your code as well as enabling and disabling assertions, both from the command line and programmatically.
|
|
Articles |
|
01 Feb 2002 |
|
| |
Diagnosing Java code: Walking the specification tightrope
Program specifications are a critical but time-consuming part of any software project. In this installment of Diagnosing Java code, author Eric Allen discusses why a well-defined specification for your code is necessary and explores traditional software engineering approaches as well as extreme programming methods. After reading this article, you'll understand how to weigh the costs and benefits of maintaining precise design specs.
|
|
Articles |
|
01 Feb 2002 |
|
| |
Java event delivery techniques
Follow along with Java programming veteran Paul Monday as he walks you through a variety of event patterns and event delivery techniques in the Java 2 platform. From a simple example based on direct Java 2 platform classes and APIs to the construction of a distributed event delivery service, you'll learn first-hand about the complexities of building a distributed event environment.
|
|
Tutorials |
|
12 Feb 2002 |
|
| |
Magic with Merlin: Java networking enhancements
John Zukowski shows you what's new and different in Java technology networking, including the latest networking features in J2SE 1.4, IPv6 support, URIs, network interfaces, secure sockets, and unbound sockets.
|
|
Articles |
|
25 Feb 2002 |
|
| |
Java theory and practice: Understanding JTS -- An introduction to transactions
The Java Transaction Service is a key element of the J2EE architecture. Together with the Java Transaction API, it enables us to build distributed applications that are robust to all sorts of system and network failures. This first installment of a three-part series covers the basics of what transactions are and why they are critical to building reliable distributed applications.
|
|
Articles |
|
01 Mar 2002 |
|
| |
Apache SOAP type mapping, Part 2: A serialization cookbook
Gavin Bong shows you how to write your own (de)serializers when none from the SOAP toolkit suit your needs.
|
|
Articles |
|
01 Mar 2002 |
|
| |
Magic with Merlin: Printing in JDK 1.4, Part 1
It seems like every new release of the Java platform since 1.1 has brought changes to the platform's printing support framework. Merlin is no exception. In this month's Magic with Merlin, John Zukowski begins a two-part discussion of the latest capabilities.
|
|
Articles |
|
01 Mar 2002 |
|
| |
A taste of "Bitter Java"
Design patterns are important to software development but they solve only half the puzzle. Antipatterns -- which describe a commonly occurring solution to a problem that generates decidedly negative consequences -- seek to address the other half by showing Java programmers how to avoid common Java traps. In this article, antipatterns expert and noted author Bruce Tate demonstrates how and why antipatterns are a necessary and complementary companion to design patterns.
|
|
Articles |
|
01 Mar 2002 |
|
| |
The MIDlets class
You want to adapt the Java Virtual Machine to a low-memory, resource-constrained, network-connected environment. Well, at the heart of the K Virtual Machine (KVM) lies a specialized Java class -- the MIDlet. In this article, Soma Ghosh teaches you the ins and outs of the MIDlet class, and shows you how to use it to build your own J2ME apps. After learning the theory behind the MIDlet, you'll see the technology in action as she builds a sample program.
|
|
Articles |
|
01 Mar 2002 |
|
| |
Merlin brings nonblocking I/O to the Java platform
The Java technology platform is long overdue for a nonblocking I/O mechanism. Fortunately, Merlin (JDK 1.4) has a magic wand for almost every occasion, and unblocking blocked I/O is this magician's specialty. Software engineers Aruna Kalagnanam and Balu G introduce the nonblocking features of Merlin's new I/O package, java.nio (NIO), and employ a socket-programming example to show you just what NIO can do.
|
|
Articles |
|
01 Mar 2002 |
|
| |
Diagnosing Java Code: Repls provide interactive evaluation
Normally, when running a Java program, it's necessary to run the program from a main() method, passing in parameters with the String[] input argument. But when a program is still being debugged, this can be a cumbersome task. In this article, Eric Allen discusses the advantages of interactively evaluating the expressions and statements in your program, and offers some Java repls (read-eval-print-loop tools) that help you with this task.
|
|
Articles |
|
01 Mar 2002 |
|
| |
