Cultured Perl: The elegance of JAPH CGI and Perl / General Development
A mainstay of the Perl culture, JAPH is a short script that produces the output "Just another Perl hacker." Although written for the beginner or intermediate Perl programmer, this article examines a few simple examples of the JAPH genre that will surprise and engage even the most seasoned devotee.
Genetic algorithms applied with Perl CGI and Perl / General Development
Based on the Darwinian principle of survival of the fittest, genetic programming uses mutation and replication to produce algorithms for creating ever-improving computer programs. In this column, you'll get to know the genetic algorithm in simple terms. Ted provides Perl implementations for some specific tasks, which you can adapt for generic use. To demonstrate the genetic algorithm, Ted breeds numbers for fitness to a formula, and letters to form English words.
Introducing inheritance to PropertyResourceBundles Java / Application Building
Creating a fully internationalized Java application using PropertyResourceBundles can present some interesting design and implementation problems, including concern over how to modularize the bundles to be used in different areas of the application. In this article, we will explore a solution based on PropertyResourceBundles, which should simplify the design and implementation problems, while promoting reuse of existing bundles.
Java Web Start Java / Application Building
Java Web Start, a new technology to assist the development of client-side Java applications, is unique in that it 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, which is scheduled to be integrated in the final release of Java 1.4, describing its implementation from both the developer and the user perspective.
JMS 1.1 simplifies messaging with unified domains Java / Communication
JMS forms the foundation of messaging in enterprise Java applications, but has always treated point-to-point messaging and publish/subscribe messaging as completely separate domains with distinctly different types of messaging destinations. The JMS 1.0.2 API provides little support for an application using both domains together, and no support for developing reusable frameworks that can work equally well with destinations of either domain.
WAP builds Java applications Java / Communication
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.
What's new in JDBC 3.0 Java / Database Integration
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. Here we summarize the key new features as outlined in Sun Microsystems' recently released Proposed Final Draft 3.0 of the JDBC specification.
Best practices in EJB exception handling Java / EJB and Javabeans
As J2EE has become the enterprise development platform of choice, more and more J2EE-based applications are going into production. One important component of the J2EE platform is the Enterprise JavaBeans (EJB) API. Together, J2EE and EJB technology offer many advantages, but with these advantages come new challenges. In particular, any problem in an enterprise system must be resolved quickly.
How to lock down your Java code Java / Getting Started
It is the time to debug your code, you'll need access to a good Java decompiler and the know-how to use it properly. At the same time, you'll also want to know how to protect your own code from prying eyes.
Improve the performance of your Java code Java / Getting Started
This article demonstrates that dynamic compilation maintains the language's semantics while static compilation often doesn't. Also 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.
Magic with Merlin: Working with preferences Java / Getting Started
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.
Exploiting ThreadLocal to enhance scalability Java / Getting Started
The ThreadLocal class appeared with little fanfare in version 1.2 of the Java platform. While support for thread-local variables has long been a part of many threading facilities, such as the Posix pthreads facility, the initial design of the Java Threads API lacked this useful feature. Further, the initial implementation was quite inefficient. For these reasons, ThreadLocal gets relatively little attention, but 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.
Weighing in on Java native compilation Java / Getting Started
Java native compilation would surely topple the JVM, taking with it the Java platform's hard-fought platform independence. But even with its growing popularity and the increasing number of native compilers on the market, native compilation has a way to go before it poses a real threat to Java code's portability.
Diagnosing Java code: The case for static types Java / Getting Started
Still, static type checking can be one of the key weapons in a powerful arsenal against introducing and for detecting bugs. In this article, Eric Allen makes a case for static type checking, explains why we should be glad that the Java language supports it, and discusses how it can be made even better.
Mash that trash -- Incremental compaction in the IBM JDK Garbage Collector Java / Getting Started
This article discusses incremental compaction, a new feature in the memory management component of IBM JDK 1.4.0. Incremental compaction is a way of spreading compaction work across different garbage collection cycles, thereby reducing pause times. The authors discuss the need for incremental compaction, the compaction phases at a high level, and some runtime parameters. They also explain how to interpret changes in the verbosegc output.