Filter by products, topics, and types of content

(0 Products)

(117 Topics)

(3 Industries)

(6 Types)

1 - 100 of 787 results | Next
Show Summaries | Hide Summaries
View Results
Title none Type none Date up
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
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.
Also available in: Japanese  
Articles 01 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.
Also available in: Japanese  
Articles 01 Mar 2001
Understanding the Java ClassLoader
This 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.
Tutorial 24 Apr 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.
Also available in: Japanese  
Articles 08 May 2001
Java bytecode:
This article gives you an understanding of Java bytecode that will enable you to be a better programmer. Like a C or C++ compiler translates source code into assembler code, Java compilers translate Java source code into bytecode. Java programmers should take the time to understand what the bytecode is, how it works, and most importantly, what bytecode is being generated by the Java compiler. In some cases, the bytecode generated is not what you expect.
Articles 01 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.
Also available in: Japanese  
Articles 17 Jul 2001
Linux Unicode programming
A multi-byte character representation system for computers, Unicode provides for the encoding and exchanging of all of the text of the world's languages. This article explains the importance of international language support and the concepts of designing and incorporating Unicode support in Linux applications.
Articles 01 Aug 2001
Introduction to JavaServer Pages
This tutorial introduces the fundamentals of JavaServer Pages (JSP) technology version 2.0 and provides an update to the original tutorial written by Noel J. Bergman that discussed JSP 1.2. This tutorial will give you a solid grasp of JSP basics and enable you to start writing your own JSP solutions.
Tutorial 28 Aug 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.
Also available in: Japanese  
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.
Also available in: Chinese   Japanese  
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.
Also available in: Japanese  
Articles 05 Sep 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.
Also available in: Japanese  
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.
Also available in: Japanese  
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
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.
Also available in: Chinese   Japanese  
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.
Also available in: Japanese  
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; how patterns are documented, categorized, and cataloged; when they should be used; what some important patterns are; and how they are implemented.
Also available in: Chinese  
Tutorial 08 Jan 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.
Also available in: Russian   Japanese  
Articles 01 Feb 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
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.
Also available in: Japanese  
Articles 01 Mar 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.
Also available in: Chinese   Russian   Japanese  
Articles 01 Mar 2002
Java theory and practice: Understanding JTS -- The magic behind the scenes
In Part 1 of this series on transactions, we covered the basics of what transactions are and why they are critical to building reliable distributed applications. In this installment, we'll explore how J2EE applications are structured into transactions, and how JTS and the J2EE container manage to make transaction services, including transaction demarcation, resource enlistment, and transaction propagation, nearly invisible to the component programmer.
Also available in: Russian   Japanese  
Articles 01 Apr 2002
Java internationalization basics
This tutorial introduces you to the Java programming language's support for multilingual and multicountry environments. The tutorial begins with a general discussion of internationalization principles and concepts, and then moves on to an overview of the specific areas of Java internationalization support. The last few sections provide a more hands-on discussion of the areas basic to any internationalized Java application: Unicode and Java characters; locales and resource bundles; and formatting dates, numbers, and currencies.
Tutorial 23 Apr 2002
Using JSSE for secure socket communication
The JDK 1.4 Java Secure Socket Extension is easy enough to use -- once you understand all the steps necessary for the initial setup and configuration. In this tutorial Greg Travis offers cookbook-style instructions for creating and installing JSSE encryption keys in a client/server application environment. Upon completion of this tutorial, you will know how to easily convert any existing client/server application to use encryption, as well as how to create a secure application from scratch.
Tutorial 30 Apr 2002
Secrets from the Robocode masters: Anti-gravity movement
Anti-gravity movement, in its many modified forms, is the movement type of choice for most expert Robocoders. With it you can define points on the map to avoid, easily create movement patterns, and dodge enemy bullets. Alisdair Owens shows you how to implement this helpful technique and provides an example bot to take out for a test drive.
Also available in: Japanese  
Articles 01 May 2002
Secrets from the Robocode masters: Dodge bullets
This tip was published in the "Cloak and turret: Learn secrets from the Robocode masters" article in the May 2002 issue of the IBM developerWorks journal.
Also available in: Chinese  
Articles 01 May 2002
Secrets from the Robocode masters: Predictive targeting
This tip was published in the "Cloak and turret: Learn secrets from the Robocode masters" article in the May 2002 issue of the IBM developerWorks journal.
Articles 01 May 2002
Secrets from the Robocode masters: Circular targeting
Circular targeting is the next step after you've mastered linear targeting. Using slightly more advanced mathematics, this system allows you to hit robots that travel in circles with perfect accuracy, all the while retaining effectiveness against those that travel in straight lines. Alisdair Owens shows you how to implement this technique and provides an example bot to take out for a test drive.
Also available in: Japanese  
Articles 01 May 2002
Best practices in EJB exception handling
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 this article, Enterprise Java programming veteran Srikanth Shenoy reveals his best practices in EJB exception handling for faster problem resolution.
Also available in: Japanese  
Articles 01 May 2002
Secrets from the Robocode masters: Tracking your opponents' movement
Every targeting algorithm has limitations because there will always be some movement pattern that it has difficulty predicting. Learn how to make your bot select the best movement algorithm for each opponent.
Also available in: Japanese  
Articles 01 May 2002
Rock 'em, sock 'em Robocode: Round 2
Get ready to venture further into the realm of Robocode with this comprehensive look at advanced robot construction and team play. Veteran Java developer and newly converted Robocode fanatic Sing Li capitalizes on Robocode's unique -- and wildly fun -- approach to learning to walk you through more advanced Java programming techniques, algorithm design, basic trigonometry, and even distributed computing principles. Your opponents won't know what hit them.
Also available in: Japanese  
Articles 01 May 2002
Java theory and practice: Understanding JTS -- Balancing safety and performance
In this final installment of his series on JTS, Brian Goetz looks at the facilities that J2EE offers for managing transaction demarcation and isolation and some guidelines for using them effectively.
Also available in: Russian   Japanese  
Articles 01 May 2002
Double-checked locking and the Singleton pattern
All programming languages have their share of idioms. Many are useful to know and use, and programmers spend valuable time creating, learning, and implementing them. The problem is that some idioms are later proven not to be all that they were purported, or to simply not work as described. Double-checked locking is one such idiom in the Java programming language that should never be used. In this article, Peter Haggar examines the roots of the double-checked locking idiom, why it was developed, and why it doesn't work.
Also available in: Japanese   Japanese  
Articles 01 May 2002
Java Media Framework basics
The Java Media Framework (JMF) is an exciting and versatile API that allows Java developers to process media in many different ways. This tutorial provides an overview of some of the major features of JMF, mainly through the use of working examples. Upon completion of this tutorial, you will understand the major players in the JMF architecture. You also will have worked directly with JMF, using live examples and source code that may be extended for more specific purposes.
Tutorial 07 May 2002
Secrets from the Robocode masters: Radar sweeps
This tip was published in the "Cloak and turret: Learn secrets from the Robocode masters" article in the May 2002 issue of the IBM developerWorks journal.
Articles 01 Jun 2002
Secrets from the Robocode masters: Extensible/reusable robots
This tip was published in the "Cloak and turret: Learn secrets from the Robocode masters" article in the May 2002 issue of the IBM developerWorks journal.
Articles 01 Jun 2002
Secrets from the Robocode masters: Polymorphic enemy cache
This tip was published in the "Cloak and turret: Learn secrets from the Robocode masters" article in the May 2002 issue of the IBM developerWorks journal.
Articles 01 Jun 2002
Secrets from the Robocode masters: RoboLeague
This tip was published in the "Cloak and turret: Learn secrets from the Robocode masters" article in the May 2002 issue of the IBM developerWorks journal.
Articles 01 Jun 2002
Java theory and practice: Safe construction techniques
Concurrent programming in Java applications is more complicated than it looks: there are several subtle (and not so subtle) ways to create data races and other concurrency hazards in Java programs. In this installment of Java theory and practice, Brian Goetz looks at a common threading hazard: allowing the this reference to escape during construction. This harmless-looking practice can cause unpredictable and undesirable results in your Java programs.
Also available in: Russian   Japanese  
Articles 01 Jun 2002
Java modeling: A UML workbook, Part 4
Granville Miller re-opens the UML workbook for an in-depth discussion of one of the fundamental components of the use case diagram: the actor. The actor is not only essential in UML modeling, it can also play an important role in creating Java applications and may even suggest patterns in J2EE application design. Follow along as Granville uses sequence and class diagrams to explain the role of the actor in use case diagramming and Java application development.
Also available in: Japanese  
Articles 04 Jun 2002
Magic with Merlin: Swinging audio
The Swing architecture has traditionally provided a means for developers to create user interfaces for Java applications that mimic native UIs. The latest version of the Java 2 Platform, Standard Edition takes this idea a step further with a mechanism for associating feedback sounds with UI actions -- the kinds of beeps and clinks that users are accustomed to hearing out of their computer speakers. Though this functionality is turned off by default, John Zukowski shows you how to unlock its power in this article.
Articles 01 Jul 2002
Java theory and practice: Thread pools and work queues
One of the most common questions posted on our Multithreaded Java programming discussion forum is some version of how to create a thread pool. In nearly every server application, the question of thread pools and work queues comes up. In this article, Brian Goetz explores the motivations for thread pools, some basic implementation and tuning techniques, and some common hazards to avoid.
Also available in: Russian   Japanese  
Articles 01 Jul 2002
Secrets from the Robocode masters: A collection of hints, tips, and advice from the Robocode masters
In this series of tips, the Robocode experts share their secrets of successful bot battle.
Articles 15 Jul 2002
Secrets from the Robocode masters: Robocode strategies
This guide to Robocode strategies reveals the genesis of the Gladiatorial League and discusses the different strategy levels of movement, shooting, and gathering information.
Articles 15 Jul 2002
Java security: Java security, Part 1: Crypto basics
The Java platform, both its base language features and library extensions, provides an excellent base for writing secure applications. In this tutorial, the first of two parts on Java security, Brad Rubin guides you through the basics of cryptography and how it is implemented in the Java programming language, using plenty of code examples to illustrate the concepts.
Tutorial 19 Jul 2002
Java security, Part 2: Authentication and authorization
The Java platform, both its base language features and library extensions, provides an excellent base for writing secure applications. In this tutorial, Part 2 of 2, Brad Rubin introduces the basic concepts of authentication and authorization and provides an architectural overview of JAAS. Through the use of a sample application he'll guide your understanding of JAAS from theory to practice. By the end of the tutorial you will have a good foundation for working with JAAS on your own.
Tutorial 19 Jul 2002
Java theory and practice: I have to document THAT?
The Java language takes an integrated approach to API documentation through the Javadoc comment convention. The Javadoc tool can help generate pretty API documentation, but the vast majority of Java API documentation out there is simply awful. Because it is part of the source code, the responsibility for the documentation of APIs falls squarely on the engineer. In this article, Brian rants about the current state of Java documentation practices and offers some guidelines on how to write more useful Javadoc.
Also available in: Russian   Japanese  
Articles 01 Aug 2002
J2EE Class Loading Demystified
Need help understanding how to use the J2EE-specified Web modules, EJB modules, and applicationclient modules? This article explains the sophisticated techniques used by J2EE and WebSphere Application Server for structuring and loading classes. Learn how to make the most of the J2EE spec when building projects with WebSphere Studio Application Developer, and how to avoid the ClassNotFoundException.
Articles 21 Aug 2002
Cross-site scripting
Cross-site scripting is a potentially dangerous security exposure that should be considered when designing a secure Web-based application. In this article, Paul describes the nature of the exposure, how it works, and has an overview of some recommended remediation strategies.
Articles 01 Sep 2002
Networking with J2ME
In this article, Ghosh discusses the javax.microedition.io and java.io classes that lie at the heart of J2ME networking.
Articles 01 Sep 2002
Java theory and practice: Hey, where'd my thread go?
If you're not careful, threads can disappear from server applications without a (stack) trace. In this article, threading expert Brian Goetz offers some techniques for both prevention and detection of threads going AWOL.
Also available in: Russian   Japanese  
Articles 01 Sep 2002
Demystifying Extreme Programming: "XP distilled" revisited, Part 2
In this month's installment of Demystifying Extreme Programming, Roy Miller explains what it means to be a programmer on an XP team and how the six programmer practices specifically fit into the picture. While all 19 practices are important, the programmer practices are vital for a team making software.
Articles 10 Sep 2002
Guidelines for using the Java 2 reference classes
In this article, Peter Haggar examines the functionality and behavior of the SoftReference, WeakReference, and PhantomReference classes and recommends programming idioms for their use.
Also available in: Japanese  
Articles 01 Oct 2002
Java theory and practice: Is that your final answer?
The final keyword is often misused -- it is overused when declaring classes and methods, and underused when declaring instance fields. This month, Java practitioner Brian Goetz explores some guidelines for the effective use of final.
Also available in: Russian   Japanese  
Articles 01 Oct 2002
Demystifying Extreme Programming: "XP distilled" revisited, Part 3
Roy Miller completes his review of XP practices by exploring the customer practices and management practices. The customer practices address the issues of determining which features should be in each release. The management practices help management give business direction to the entire team and keep them focused on the problem at hand. With the programmer practices and joint practices discussed in previous articles, you'll now have the complete picture of XP practices.
Articles 08 Oct 2002
Unit testing with mock objects
Mock objects are a useful way to write unit tests for objects that act as mediators. However, when the tested object must create the domain object, how does it know to create a mock domain object instead of the true domain object? In this article, software consultants Alexander Day Chaffee and William Pietri present a refactoring technique to create mock objects based on the factory method design pattern.
Also available in: Japanese  
Articles 01 Nov 2002
Getting started with the Eclipse Platform
This article gives you an overview of the Eclipse Platform, including its origin and architecture. Starting with a brief discussion about the open source nature of Eclipse and its support for multiple programming languages, this article then demonstrates the Java development environment with a simple program example. This article also surveys some of the software development tools that are available as plug-in extensions, and demonstrates a plug-in extension for UML modeling.
Also available in: Russian   Japanese   Spanish  
Articles 01 Nov 2002
Java theory and practice: Concurrency made simple (sort of)
Like many other application infrastructure services, concurrency utility classes such as work queues and thread pools are often needlessly rewritten from scratch for every project. This month, Brian Goetz offers an introduction to Doug Lea's util.concurrent package, a high-quality, widely used, open source package of concurrency utilities.
Also available in: Russian   Japanese  
Articles 01 Nov 2002
Introduction to the J2EE Connector Architecture
IBM e-business Architect Willy Farrell provides a hands-on, step-by-step introduction to the J2EE Connector Architecture, the most relevant components beneath that architecture, and the functionality of each of those components.
Tutorial 12 Nov 2002
Developing Eclipse plug-ins
In this article, author David Gallardo shows you how to create Eclipse plug-ins using the Plug-in Development Environment's code generation wizard. You'll learn how to run and debug the plug-in in the run-time workbench and install the completed plug-in in Eclipse. He also examines issues relating to packaging plug-ins -- including maintaining version information, upgrading functionality in the form of plug-in fragments, and combining plug-ins to create complete features.
Also available in: Chinese   Russian   Japanese  
Articles 01 Dec 2002
Java theory and practice: Where's your point?
Many programmers go their entire career without using fixed point or floating point numbers, with the possible exception of the odd timing test or benchmark. The Java language and class libraries support two sorts of non-integral numeric types -- IEEE 754 floating point and arbitrary-precision decimal. In this article, Brian Goetz looks at some of the traps and gotchas often encountered when using non-integral numeric types in Java programs.
Also available in: Russian   Japanese  
Articles 01 Jan 2003
Diagnosing Java code: Design for easy code maintenance
This month, Eric Allen explains how avoiding and controlling gratuitous mutation is key to retaining code robustness while making the code easier to maintain. He focuses on such concepts as functional style code crafting and ways of marking fields, methods, and classes to handle and prevent mutability. Also, Eric explains the role of unit testing and refactoring in this task, and offers two tools to aid in refactoring efforts.
Also available in: Japanese  
Articles 01 Jan 2003
J2EE pathfinder: J2EE technologies for the stateless network
The J2EE pathfinder series offers a window into one or more J2EE technologies, often weighing several of them to help you make informed decisions. In this first installment in the series, LearningPatterns Senior Mentor Kyle Gabhart compares two J2EE technologies for the stateless network: servlets and EJB technology.
Articles 01 Feb 2003
A JSTL primer, Part 1: The expression language
In this article, software engineer Mark Kolb shows you how to use the JSP Standard Tag Library (JSTL) to avoid using scripting elements in your JSP pages. You'll learn how to simplify software maintenance by removing source code from the presentation layer. And you'll learn about JSTL's simplified expression language.
Also available in: Japanese  
Articles 11 Feb 2003
Java theory and practice: To mutate or not to mutate?
In this article, Brian Goetz explains some of the benefits of immutability and some guidelines for constructing immutable classes. While immutability may not necessarily make sense for all classes, most programs have at least a few classes that would benefit from being immutable.
Also available in: Russian   Japanese  
Articles 18 Feb 2003
Getting started with JML
The Java Modeling Language (JML) is a notation for detailed design that encourages a new way of thinking about methods and classes. In this primer, Java programming consultant Joe Verzulli introduces JML and some of its most important declarative constructs.
Articles 18 Mar 2003
A JSTL primer, Part 2: Getting down to the core
Mark Kolb continues his exploration into the JSP Standard Tag Library (JSTL) and the core library with a look at tags to assist with flow control and URL management.
Also available in: Japanese  
Articles 18 Mar 2003
Taming your Tomcat: Filtering tricks for Tomcat 5
The new Tomcat 5 server takes filters to a new level of deployment flexibility. In this article, Sing Li takes you on a guided tour of the new enhancement and gives you some hands-on training. See how Tomcat 5 can benefit Web application frameworks and lead ultimately to the design of maintainable high-performance systems.
Also available in: Japanese  
Articles 25 Mar 2003
Magic with Merlin: The ins and outs of Merlin's new I/O buffers
In this Magic with Merlin article, resident Java programming wizard John Zukowski shows how to manipulate the data buffers underlying the J2SE new I/O packages, for such tasks as reading/writing primitives and working with memory-mapped files.
Also available in: Japanese  
Articles 25 Mar 2003
Java theory and practice: Performance management -- do you have a plan?
Brian Goetz discusses some of the most common performance mistakes he's seen in projects using the Java language. While there are many types of programming choices that can lead to performance problems, often mistakes of management and approach are the culprit.
Also available in: Russian   Japanese  
Articles 25 Mar 2003
Java theory and practice: Urban performance legends
Many pointers and tips about Java performance tuning are a lot like urban legends -- someone, somewhere, passes on a tip that has (or had) some basis in fact, but through its continued retelling, has lost what truth it once contained. Brian Goetz examines some of these urban performance legends and sets the record straight.
Also available in: Russian   Japanese  
Articles 22 Apr 2003
Java programming dynamics, Part 1: Java classes and class loading
Take a look at what goes on behind the scenes of executing your Java application in this new series on the dynamic aspects of Java programming. Enterprise Java expert Dennis Sosnoski gives the scoop on the Java binary class format and what happens to classes inside the JVM.
Also available in: Chinese   Japanese  
Articles 29 Apr 2003
Diagnosing Java code: Java generics without the pain, Part 1
This article introduces generic types and the features to support them scheduled for inclusion in Tiger, Java version 1.5, scheduled for release late in 2003. Eric Allen offers code samples that illustrate the ups and downs around generic types by focusing on such Tiger features as limitations on primitive types, constrained generics, and polymorphic methods.
Also available in: Japanese  
Articles 20 May 2003
A JSTL primer, Part 4: Accessing SQL and XML content
A hallmark of Web-based applications is the integration of multiple subsystems. Two of the most common mechanisms for exchanging data between such subsystems are SQL and XML. In this article, Mark Kolb concludes his coverage of JSTL with an introduction to the sql and xml libraries for accessing database and XML content in JSP pages.
Also available in: Japanese  
Articles 20 May 2003
Java theory and practice: Hashing it out
In this installment of Java theory and practice, Java developer Brian Goetz shows you the rules and guidelines you should follow when creating Java classes in order to define hashCode() and equals() effectively and appropriately.
Also available in: Russian   Japanese  
Articles 27 May 2003
Java programming dynamics, Part 2: Introducing reflection
In Part 2 of his series on Java platform internals, Dennis Sosnoski provides an introduction to using reflection, as well as a look at some of the costs involved. You'll also find out how the Java Reflection API lets you hook into objects at run time.
Also available in: Chinese   Japanese  
Articles 03 Jun 2003
Working with James, Part 2: Build e-mail based applications with matchers and mailets
This is the second of two articles focused on developing applications with the James e-mail server from the Apache group. In this article, go beyond the basic James infrastructure and implement a practical application for flagging users as available or unavailable, and for automatically sending custom messages to senders from users who chose to make themselves unavailable.
Also available in: Japanese  
Articles 10 Jun 2003
Working with James, Part 1: An introduction to Apache's James enterprise e-mail server
This article is the first in a two-part series on the Java Apache Mail Enterprise Server, also known as James. It lays a foundation for understanding James and for developing server-side e-mail applications. The article provides a high-level overview, briefly touches on the Apache group's design objectives, and describes how to install and configure a workable development environment. You can also take a brief tour of the features supported by James.
Also available in: Japanese  
Articles 10 Jun 2003
JSP best practices: Import content to your Web site
In addition to passing around parameters and manipulating content from local files, c:import can be used to pull in content from external sites. In this installment of JSP best practices, veteran Web developer Brett McLaughlin shows you how.
Articles 17 Jun 2003
Java theory and practice: Whose object is it, anyway?
While garbage collection means that Java developers don't have to worry (much) about memory leaks, sometimes we still do have to worry about object ownership to prevent data races and unwanted side effects. In this article, Brian Goetz identifies some of the situations where Java developers must pay attention to object ownership.
Also available in: Russian   Japanese  
Articles 24 Jun 2003
Getting started with new I/O (NIO)
The new input/output (NIO) library, introduced with JDK 1.4, provides high-speed, block-oriented I/O in standard Java code. This hands-on tutorial covers the NIO library in great detail, from the high-level concepts to under-the-hood programming detail. You'll learn about crucial I/O elements like buffers and channels, and examine how standard I/O works in the updated library.
Tutorials 09 Jul 2003
Java programming dynamics, Part 3: Applied reflection
Learn how the Java Reflection API can be used to simplify the job of command line argument processing. In this article, Java consultant Dennis Sosnoski outlines an open source library that makes command line arguments practically handle themselves.
Also available in: Japanese  
Articles 15 Jul 2003
Java theory and practice: Concurrent collections classes
In addition to many other useful concurrency building blocks, Doug Lea's util.concurrent package contains high-performance, thread-safe implementations for workhorse collection types List and Map. This month, Brian Goetz shows you how many concurrent programs will benefit from simply replacing Hashtable or synchronizedMap with ConcurrentHashMap.
Also available in: Russian   Japanese  
Articles 23 Jul 2003
Java theory and practice: Building a better HashMap
Brian Goetz dives into the code of ConcurrentHashMap and looks at how it achieves excellent throughput and concurrency without compromising thread safety.
Also available in: Russian   Japanese  
Articles 21 Aug 2003
Refactoring for everyone
Eclipse provides a powerful set of automated refactorings that, among other things, let you rename Java elements, move classes and packages, create interfaces from concrete classes, turn nested classes into top-level classes, and extract a new method from sections of code in an old method. Becoming familiar with Eclipse's refactoring tools is a good way to improve your productivity. This survey of Eclipse's refactoring features, with examples, demonstrates how and why to use each.
Also available in: Russian   Japanese   Vietnamese  
Articles 09 Sep 2003
Simplify enterprise Java authentication with single sign-on
Faheem Khan shows you how to implement single sign-on (SSO) functionality on the Java platform. You'll see how you can use the GSS-API and Kerberos standards to abstract away some of the difficulty, and implement an SSO-based architecture with relative ease.
Articles 09 Sep 2003
Java programming dynamics, Part 4: Class transformation with Javassist
Java consultant Dennis Sosnoski takes a look at Javassist, the bytecode manipulation library that's the basis for the aspect-oriented programming features being added to the widely used JBoss application server. You'll find out the basics of transforming existing classes with Javassist and see both the power and the limitations of this framework's source code approach to classworking.
Also available in: Chinese   Japanese  
Articles 16 Sep 2003
Java theory and practice: Characterizing thread safety
In July our concurrency expert Brian Goetz described the Hashtable and Vector classes as being conditionally thread-safe. Shouldn't a class either be thread-safe or not? Unfortunately, thread safety is not an all-or-nothing proposition, and it is surprisingly difficult to define. But, as Brian explains in this month's Java theory and practice, it is critically important that you make an effort to classify the thread safety of your classes in their Javadoc.
Also available in: Russian   Japanese  
Articles 23 Sep 2003
Eclipse and HSQLDB: Embedding a relational database server into Eclipse, Part 1
This article shows how to develop a plug-in that embeds the HSQLDB pure-Java relational database server into the Eclipse Workbench. Although not as powerful as DB2 and not as popular as MySQL, HSQLDB (the hypersonic SQL database) can satisfy the needs of a wide range of Java applications, because of its extensibility and low memory/processor requirements.
Also available in: Japanese   Spanish  
Articles 30 Sep 2003
SIP: Creating next-generation telecom applications
Developing applications to run on a telecommunications network has never been easier. Instead of yesterday's proprietary protocols and interfaces, you now can use open, Internet-based standards such as the Session Initiation Protocol (SIP). Combined with the power and simplicity of Java technology in the form of the SIP Servlet API, an application developer can create and deploy new services to users in a fraction of the time it previously took. Taking advantage of this revolution means being conversant with SIP. In this article, you'll discover how SIP operates and, building on that knowledge, you will learn how to use the Java SIP Servlet API to build the exciting new applications of the future. The SIP tour concludes with code examples that demonstrate SIP application development in action.
Articles 30 Sep 2003
Advanced DAO programming
J2EE developers use the Data Access Object (DAO) design pattern to separate low-level data access logic from high-level business logic. Implementing the DAO pattern involves more than just writing data access code. In this article, Java developer Sean C. Sullivan discusses three often overlooked aspects of DAO programming: transaction demarcation, exception handling, and logging.
Also available in: Japanese  
Articles 07 Oct 2003
JAR files revealed
Most Java programmers are familiar with basic operations on JAR files. But few programmers are aware of the power of the JAR file format. In this article, the authors explore the many features and benefits of the JAR format, including packaging, executable jar files, security, and indexing.
Also available in: Chinese  
Articles 09 Oct 2003
Store objects using the Preferences API
This article offers an introduction to the Preferences API, a lightweight, cross-platform persistence API introduced in JDK 1.4 and designed to store small amounts of data. Greg Travis explains how objects are stored, demonstrates the process in action, and provides a code library to do the work.
Also available in: Chinese   Japanese  
Articles 14 Oct 2003
Java theory and practice: A brief history of garbage collection
Garbage collection has been an integral part of many programming languages and has been in use since the early 1960s. In this article, Brian Goetz describes the most common techniques for garbage collection.
Also available in: Russian   Japanese  
Articles 28 Oct 2003
Monitor and estimate logical log usage in Informix Dynamic Server
This article will discuss in detail how to configure and manage logical logs. The article will also demonstrate a real life example how to estimate and predict logical log usage.
Articles 18 Nov 2003
Equipping SWT applications with content assistants
For users of the Eclipse Java editor, content assistants are a well-known feature. You can easily add this feature to any SWT-based application, either a stand-alone application or a plug-in to the Eclipse workbench.
Also available in: Japanese  
Articles 19 Nov 2003
Java theory and practice: Garbage collection in the HotSpot JVM
Brian Goetz examines how the 1.4.1 JVM actually handles garbage collection, including some of the new garbage collection options for multiprocessor systems.
Also available in: Russian   Japanese  
Articles 25 Nov 2003
J2ME 101, Part 3: Inside the Record Management System
MIDP does not use a filesystem to save application data. Rather, MIDP stores all information in non-volatile memory, using a storage system called the Record Management System (RMS). In In this article, the first in a two-part companion series to the J2ME 101 tutorial series, author and developer John Muchow introduces the basics of the RMS application interface, then walks you through several development examples that illustrate its functionality.
Articles 12 Dec 2003
J2ME 101, Part 4: The Generic Connection Framework
The Generic Connection Framework (GCF) provides an extensible, generic I/O framework for resource constrained devices. In this final installment in the J2ME 101 series, author John Muchow walks you through the GCF interfaces, showing you how they facilitate the development and support of various types of network and file I/O on MIDP.
Articles 13 Jan 2004
1 - 100 of 787 results | Next
Show Summaries | Hide Summaries