Filter by products, topics, and types of content

(0 Products)

(122 Topics)

(4 Industries)

(6 Types)

1 - 94 of 94 results
Show Summaries | Hide Summaries
View Results
Title none Type none Date none
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
Java theory and practice: Decorating with dynamic proxies
The dynamic proxy facility, part of the java.lang.reflect package and added to the JDK in version 1.3, allows programs to create proxy objects, which can implement one or more known interfaces and dispatch calls to interface methods programmatically using reflection instead of using the built-in virtual method dispatch. This process allows implementations to "intercept" method calls and reroute them or add functionality dynamically. This month, Brian Goetz explores several applications for dynamic proxies.
Also available in: Russian   Japanese  
Articles 30 Aug 2005
Java theory and practice: Dynamic compilation and performance measurement
Writing and interpreting performance benchmarks for dynamically compiled languages, such as Java, is far more difficult than for statically compiled languages like C or C++. In this installment of Java theory and practice, Brian Goetz explores a few of the many ways in which dynamic compilation can complicate performance testing.
Also available in: Russian   Japanese  
Articles 21 Dec 2004
Java theory and practice: Be a good (event) listener
The Observer pattern, most often seen in Swing development, is also very useful for decoupling components in situations other than GUI applications. However, some common pitfalls with registering or invoking listeners exist. In this installment of Java theory and practice, Java therapist Brian Goetz offers some feel-good advice on how to be a good listener -- and how to be nice to your listeners, too.
Also available in: Russian   Japanese  
Articles 26 Jul 2005
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
Java theory and practice: More flexible, scalable locking in JDK 5.0
JDK 5.0 offers developers some powerful new choices for developing high-performance concurrent applications. For example, the ReentrantLock class in java.util.concurrent.lock is offered as a replacement for the synchronized facility of the Java language -- it has the same memory semantics, the same locking semantics, better performance under contention, and features not offered by synchronized. Does this mean that we should forget about synchronized, and instead use ReentrantLock exclusively? Concurrency expert Brian Goetz returns from his summer hiatus to supply the answer.
Also available in: Russian   Japanese  
Articles 26 Oct 2004
Java theory and practice: Make database queries without the database
When you have a hammer, everything looks like a nail (as the old saying goes). But what if you don't have a hammer? Well, sometimes, you can borrow a hammer. Then, hammer in hand, you can bang the virtual nails with the borrowed hammer, return it, and no one is the wiser. In this month's Java theory and practice, Brian Goetz demonstrates how data manipulation hammers such as SQL or XQuery can be applied to ad-hoc data.
Also available in: Russian   Japanese  
Articles 31 May 2005
Java theory and practice: Enable initialization atomicity
Decisions made during API design can have an effect on the API's usability. In designing an API, you need to put yourself in your user's shoes, imagining how the API might be used, and try and make the common use cases convenient for the user. This month, columnist Brian Goetz discusses an API design technique, the self-return idiom, that can make life easier for users of your API in certain circumstances. Share your thoughts on this article with the author and other readers in the accompanying discussion forum.
Also available in: Russian   Japanese  
Articles 27 Apr 2005
Java theory and practice: Screen-scraping with XQuery
XQuery is a W3C standard for extracting information from XML documents, currently spanning 14 working drafts. While the majority of interest in XQuery is centered around querying large bases of semi-structured document data, XQuery can be surprisingly effective for some much more mundane uses as well. In this month's Java theory and practice, columnist Brian Goetz shows you how XQuery can be used effectively as an HTML screen-scraping engine.
Also available in: Russian   Japanese  
Articles 22 Mar 2005
Java theory and practice: Anatomy of a flawed microbenchmark
Software engineers are notoriously obsessed, sometimes excessively, with performance. While sometimes performance is the most important requirement in a software project, as it might be when developing protocol routing software for a high-speed switch, most of the time performance needs to be balanced against other requirements, such as functionality, reliability, maintainability, extensibility, time to market, and other business and engineering considerations. In this month's Java theory and practice, columnist Brian Goetz explores why it is so much harder to measure the performance of Java language constructs than it looks.
Also available in: Russian   Japanese  
Articles 22 Feb 2005
Java theory and practice: Generics gotchas
Generic types, added in JDK 5.0, are a significant enhancement to type safety in the Java language. However, some aspects of generics may seem confusing, or even downright bizarre, to first-time users. In this month's Java theory and practice, Brian Goetz examines the common pitfalls that ensnare first-time users of generics.
Also available in: Russian   Japanese  
Articles 25 Jan 2005
Java theory and practice: Going atomic
Until JDK 5.0, it was not possible to write wait-free, lock-free algorithms in the Java language without using native code. The addition of the atomic variable classes in java.util.concurrent changes that situation. Follow along with concurrency expert Brian Goetz as he explains how these new classes have enabled the development of highly scalable nonblocking algorithms in the Java language. Share your thoughts on this article with the author and other readers in the accompanying discussion forum.
Also available in: Russian   Japanese  
Articles 23 Nov 2004
Java theory and practice: State replication in the Web tier
How state will be managed and replicated in a clustered server application has a significant impact on the scalability of the application. Many Java applications store state in the HttpSession provided by the Servlet API. This article examines some of the options for HttpSession replication and how to most effectively use HttpSession to provide good scalability and performance.
Also available in: Russian   Japanese  
Articles 29 Jul 2004
Java theory and practice: Kill bugs dead
The FindBugs tool is a powerful tool for auditing your code for compliance with good design practices and represents a huge step forward in the state-of-the-art of real-world code analysis tools.
Also available in: Russian   Japanese  
Articles 29 Jun 2004
Java theory and practice: The exceptions debate
When should you use checked versus unchecked exceptions in Java classes? The prevailing wisdom is to use checked exceptions in nearly all cases, but some Java luminaries have begun to think otherwise. This month, columnist Brian Goetz examines the exceptions debate and offers guidance on when and how to use unchecked exceptions.
Also available in: Russian   Japanese  
Articles 25 May 2004
Java theory and practice: Coaxing J2EE out of the container
Most projects fall squarely into either the category of J2EE application or J2SE application. However, there are a number of J2EE technologies that can exist outside of the J2EE container, and some J2SE applications may benefit from them. This month, Brian Goetz looks at how some J2EE services can be used in J2SE applications. Share your thoughts on this article with the author and other readers in the accompanying discussion forum.
Also available in: Russian   Japanese  
Articles 20 Apr 2004
Java theory and practice: Fixing the Java Memory Model, Part 2
JSR 133, which has been active for nearly three years, has recently issued its public recommendation on what to do about the Java Memory Model (JMM). In Part 1 of this series, columnist Brian Goetz focused on some of the serious flaws that were found in the original JMM, which resulted in some surprisingly difficult semantics for concepts that were supposed to be simple. This month, he reveals how the semantics of volatile and final will change under the new JMM, changes that will bring their semantics in line with most developers' intuition. Some of these changes are already present in JDK 1.4; others will have to wait until JDK 1.5. Share your thoughts on this article with the author and other readers in the accompanying discussion forum.
Also available in: Russian   Japanese  
Articles 30 Mar 2004
Java theory and practice: Fixing the Java Memory Model, Part 1
JSR 133, which has been active for nearly three years, has recently issued its public recommendation on what to do about the Java Memory Model (JMM). Several serious flaws were found in the original JMM, resulting in some surprisingly difficult semantics for concepts that were supposed to be simple, like volatile, final, and synchronized. In this installment of Java theory and practice, Brian Goetz shows how the semantics of volatile and final will be strengthened in order to fix the JMM. Some of these changes have already been integrated in JDK 1.4; others are slated for inclusion in JDK 1.5.
Also available in: Russian   Japanese  
Articles 24 Feb 2004
Java theory and practice: Garbage collection and performance
The past two installments of Java theory and practice have discussed various techniques for garbage collection and the basics of the JDK 1.4.1 garbage collectors. This month, columnist Brian Goetz looks at the performance impact of the choice of collector, how various coding idioms interact with the garbage collector, and how allocation and other related costs have changed in Java virtual machines over the past several years.
Also available in: Russian   Japanese  
Articles 27 Jan 2004
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
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
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
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
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: 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 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 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: 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
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
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
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
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
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
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
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 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
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 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: Urban performance legends, revisited
The Java language is the target of a lot of abuse for performance. And while some of it may well be deserved, a tour of message board and newsgroup postings on the subject shows that there is a great deal of misunderstanding about how a Java Virtual Machine (JVM) actually works. In this month's Java theory and practice, Brian Goetz pokes some holes in the oft-repeated performance myth of slow allocation in JVMs.
Also available in: Russian   Japanese  
Articles 27 Sep 2005
Java theory and practice: Managing volatility
The Java language contains two intrinsic synchronization mechanisms: synchronized blocks (and methods) and volatile variables. Both are provided for the purpose of rendering code thread-safe. Volatile variables are the weaker (but sometimes simpler or less expensive) of the two -- but also easier to use incorrectly. In this installment of Java theory and practice, Brian Goetz explores some patterns for using volatile variables correctly and offers some warnings about the limits of its applicability.
Articles 19 Jun 2007
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: Are all stateful Web applications broken?
The session state management mechanism provided by the Servlets framework, HttpSession, makes it easy to create stateful applications, but it is also quite easy to misuse. Many Web applications that use HttpSession for mutable data (such as JavaBeans classes) do so with insufficient coordination, exposing themselves to a host of potential concurrency hazards.
Also available in: Russian   Japanese  
Articles 23 Sep 2008
Java theory and practice: Going wild with generics, Part 2
Wildcards can be very confusing when it comes to generics in the Java language, and one of the most common mistakes is to fail to use one of the two forms of bounded wildcards ("super T" and "? extends T") when needed. You've made this mistake? Don't feel bad, even the experts have, and this month Brian Goetz shows you how to avoid it.
Also available in: Japanese  
Articles 01 Jul 2008
Java theory and practice: Going wild with generics, Part 1
One of the most complicated aspects of generics in the Java language is wildcards, and in particular, the treatment and confusing error messages surrounding wildcard capture. In this installment of Java theory and practice, veteran Java developer Brian Goetz deciphers some of the weirder-looking error messages emitted by javac and offers some tricks and workarounds that can simplify using generics.
Also available in: Chinese   Russian   Japanese  
Articles 06 May 2008
Java theory and practice: Stick a fork in it, Part 2
One of the additions to the java.util.concurrent packages coming in Java 7 is a library for fork-join-style parallel decomposition. In part one of this series, author Brian Goetz shows how fork-join provides a natural mechanism for decomposing many algorithms to effectively exploit hardware parallelism. In this article, he'll cover the ParallelArray classes, which simplify parallel sorting and searching operations on in-memory data structures.
Also available in: Russian   Japanese  
Articles 04 Mar 2008
Java theory and practice: Stick a fork in it, Part 1
One of the additions to the java.util.concurrent packages coming in Java 7 is a framework for fork-join style parallel decomposition. The fork-join abstraction provides a natural mechanism for decomposing many algorithms to effectively exploit hardware parallelism. The next installment in this series covers the ParallelArray classes, which simplify parallel sorting and searching operations on in-memory data structures.
Also available in: Chinese   Russian   Japanese  
Articles 13 Nov 2007
Java theory and practice: The closures debate
Everyone has a favorite feature idea or two for adding to the Java language. With the open-sourcing of the Java platform and the rise in popularity of other languages for server-side applications (JavaScript and Ruby, to name two), the debate over the future of the Java language has never been more vigorous. Should the Java language embrace major new additions, such as closures? Or is that too much messing with a good thing? In this month's Java theory and practice, Brian Goetz reviews the concepts involved and provides details on the two competing closures proposals.
Also available in: Chinese  
Articles 24 Apr 2007
Java theory and practice: Using Java 5 language features in earlier JDKs
Java 5 added a number of powerful language features: generics, enumerations, annotations, autoboxing, and the enhanced for loop. However, many shops are still tied to JDK 1.4 or earlier and may be for some time to come. But it's still be possible for those developers to take advantage of these powerful language features while continuing to deploy on earlier JVMs. Brian Goetz returns from his hiatus in this installment of Java theory and practice to demonstrate how.
Also available in: Chinese   Russian   Japanese  
Articles 27 Feb 2007
Java theory and practice: Instrumenting applications with JMX
Debuggers and profilers can provide insight into an application's behavior, but we usually only break out these tools when there's a serious problem. Building monitoring hooks into an application can make it easier to understand what your programs are doing without breaking out the debugger. Now that Java Management Extensions (JMX) is built into the Java SE platform, and the jconsole viewer provides a universal monitoring GUI, using JMX to provide a window into your application is easier and more effective than ever.
Also available in: Chinese   Russian   Japanese  
Articles 19 Sep 2006
Java theory and practice: Testing with leverage, Part 3
The first two installments in this series showed how static analysis tools like FindBugs can provide greater leverage in managing software quality by focusing on entire categories of bugs rather than on specific bug instances. In this final installment on testing, Brian Goetz examines another technique for smoking out bugs that violate design rules: aspects.
Also available in: Russian  
Articles 22 Aug 2006
Java theory and practice: Testing with leverage, Part 2
June's Java theory and practice column demonstrated how static analysis tools like FindBugs can bring greater leverage to bear on managing software quality by focusing on entire categories of bugs rather than on specific bug instances. In this month's installment, resident exterminator Brian Goetz details the process of constructing and tuning a nontrivial bug pattern detector.
Also available in: Russian   Japanese  
Articles 25 Jul 2006
Java theory and practice: Testing with leverage, Part 1
Back in June 2004, veteran exterminator Brian Goetz introduced the FindBugs static code analysis tool, which can detect bugs even in well-tested software. This month, he revisits that topic and looks at how static analysis tools can change the way you manage software quality by aiming development resources at entire classes of bugs rather than specific instances.
Also available in: Chinese   Russian  
Articles 20 Jun 2006
Java theory and practice: Dealing with InterruptedException
Many Java language methods, such as Thread.sleep() and Object.wait(), throw InterruptedException. You can't ignore it because it's a checked exception, but what should you do with it? In this month's Java theory and practice, concurrency expert Brian Goetz explains what InterruptedException means, why it is thrown, and what you should do when you catch one.
Also available in: Chinese   Russian   Japanese  
Articles 23 May 2006
Java theory and practice: Introduction to nonblocking algorithms
Java 5.0 makes it possible for the first time to develop nonblocking algorithms in the Java language, and the java.util.concurrent package uses this capability extensively. Nonblocking algorithms are concurrent algorithms that derive their thread safety not from locks, but from low-level atomic hardware primitives such as compare-and-swap. Nonblocking algorithms can be extremely difficult to design and implement, but they can offer better throughput and greater resistance to liveness problems such as deadlock and priority inversion. In this installment of Java theory and practice, concurrency guru Brian Goetz illustrates how several of the simpler nonblocking algorithms work.
Also available in: Russian   Japanese  
Articles 18 Apr 2006
Java theory and practice: Good housekeeping practices
Garbage collection is nearly everyone's favorite feature of the Java platform; it simplifies development and eliminates entire categories of potential code errors. But while garbage collection generally allows you to ignore resource management, sometimes you have to do some housekeeping on your own. In this month's Java theory and practice, Brian Goetz discusses the limitations of garbage collection and identifies situations when you have to do your own housecleaning.
Also available in: Russian   Japanese  
Articles 21 Mar 2006
Java theory and practice: The pseudo-typedef antipattern
The addition of generics to the Java language complicated the type system and increased the verbosity of many variable and method declarations. Because no "typedef" facility was provided for defining short names for types, some developers have turned to extension as a "poor man's typedef," with less than good results. In this month's Java theory and practice, Java expert Brian Goetz explains the limitations of this "antipattern."
Also available in: Russian   Japanese  
Articles 21 Feb 2006
Java theory and practice: Plugging memory leaks with soft references
In the previous installment of Java theory and practice, Java sanitation engineer Brian Goetz examined weak references, which let you put the garbage collector on notice that you want to maintain a reference to an object without preventing it from being garbage collected. This month, he explains another form of Reference object, soft references, which can also enlist the aid of the garbage collector in managing memory usage and eliminating potential memory leaks.
Also available in: Russian   Japanese  
Articles 24 Jan 2006
Java theory and practice: Plugging memory leaks with weak references
While programs in the Java language are theoretically immune from "memory leaks," there are situations in which objects are not garbage collected even though they are no longer part of the program's logical state. This month, sanitation engineer Brian Goetz explores a common cause of unintentional object retention and shows how to plug the leak with weak references.
Also available in: Chinese   Russian   Japanese  
Articles 22 Nov 2005
Java theory and practice: Synchronization optimizations in Mustang
In the September installment of Java theory and practice, columnist Brian Goetz examined escape analysis, an optimization that has been on the "to-do" list for many JVMs for quite some time and which is expected in HotSpot in the Mustang (Java SE 6) release. Escape analysis can be used to convert heap-based object allocation into the less-expensive, stack-based allocations, but it can also be used to make other optimization decisions as well, including optimizing the use of synchronization. This month Brian introduces some of the synchronization optimizations slated for Mustang. Note: This column describes features of a future version of Sun's HotSpot JVM implementation. Specific features discussed herein may or may not appear in Java SE 6 ("Mustang"); some may be delayed until Java SE 7 ("Dolphin").
Also available in: Russian  
Articles 18 Oct 2005
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
IBM WebSphere Developer Technical Journal: The top 10 (more or less) J2EE best practices
A top 10 (+2) list of the most important best practices for J2EE application development.
Articles 12 May 2004
Best practices for location-aware services
This tutorial gets you started with IBM Enterprise LAS middleware. Learn the concepts behind the middleware and write a simple location-tracking Web application with the help of Asynchronous JavaScript and XML (Ajax) and Scalable Vector Graphics (SVG) technologies. With these best practices in mind, you'll be on your way to building faster location-tracking systems that can easily integrate with positioning/sensoring technologies, such as RFID and Zigbee.
Tutorial 06 Jun 2006
Best practices for developing Eclipse plugins
This tutorial highlights best practices when marking information to resources using markers, and then introduces annotations and decorators that you use to highlight markers within the workbench. By extending extension points, you can reuse and adapt the built-in functions in Eclipse and perform advanced resource marking, such as moving a text marker when editing text. We discuss methods that take advantage of the plugin model, which allows for an efficient, high performance, and integrated look and feel plugin.
Also available in: Chinese   Japanese   Portuguese  
Tutorial 16 Aug 2011
JSF 2 fu: Best practices for composite components
In this installment of JSF 2 fu, you'll learn five best practices for implementing JavaServer Faces composite components. By following these guidelines, you'll make it easy for page authors to extend your custom components.
Also available in: Chinese   Japanese   Portuguese  
Articles 11 Jan 2011
Best practices for using the Java Native Interface
The Java Native Interface (JNI) is a standard Java API that enables Java code to integrate with code written in other programming languages. JNI can be a key element in your toolkit if you want to leverage existing code assets -- for example, in a service-oriented architecture (SOA) or a cloud-based system. But when used without due care, JNI can quickly lead to poorly performing and unstable applications. This article identifies the top 10 JNI programming pitfalls, provides best practices for avoiding them, and introduces the tools available for implementing these practices.
Also available in: Chinese   Japanese  
Articles 07 Jul 2009
Write high performance Java data access applications, Part 3: pureQuery API best practices
pureQuery is a high-performance data access platform that makes it easier to develop, optimize, secure, and manage data access. It consists of tools, APIs, a runtime, and client monitoring services. The previous articles in this series introduced the use of data access objects (DAOs) and built-in inline methods to access the database. This article summarizes some best practices for development using pureQuery and gives you real-world scenarios that illustrate how to implement these practices.
Also available in: Chinese   Russian  
Articles 23 Sep 2010
Ropes: Theory and practice
Systems that manipulate large quantities of string data are poorly served by the Java language's default String and StringBuilder classes. A rope data structure can be a better alternative. This article introduces Ropes for Java, a rope implementation for the Java platform; explores performance issues; and provides pointers for effective use of the library.
Also available in: Chinese   Russian   Japanese  
Articles 12 Feb 2008
IBM WebSphere Developer Technical Journal: The top Java EE best practices
This is an updated version of a similarly-named article published in the IBM WebSphere Developer Technical Journal in 2004. This revision takes into account changing technology trends and, more importantly, recommends certain practices that the authors assumed would be commonly followed, but, as they have learned, are not.
Also available in: Chinese  
Articles 24 Jan 2007
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
Get the most out of high performance message-driven beans and WebSphere Application Server
When high performance is a priority, it is important to make sure that both the application server and the JMS provider are properly configured. Explore the configuration options available to you in IBM WebSphere Application Server, and learn how to handle potential limitations and performance issues with some general rules of thumb and some best practices.
Articles 31 Aug 2005
Comment lines: Scott Johnson: Take a lifetime to be a good (and happy) programmer
A happy programmer knows what they're good at and what is really involved in that pie-in-the-sky job he or she desires. Inspired by an article on the average programmer's big rush to learn the practice of programming, the author shares his views on the topic.
Articles 17 Aug 2005
EJB Programming with snippets in WebSphere Studio V5.1.2
EJBs provide a powerful mechanism for distributed computing and container-managed persistence. The programming model, however, can be complex. This article shows you how to use WebSphere Studio to automate EJB programming by generating the client code and hiding the complexity. Along the way, it explains how the code works and shows best practices for simplicity and portability.
Articles 06 Oct 2004
Control your test-environment with DbUnit and Anthill
The inception of the Extreme Programming methodology has brought test-driven development and continuous integration into mainstream Java development practices. Applying these techniques to Java server-side development can quickly become a nightmare if you don't have the right tools. In this article, software developer Philippe Girolami describes how to deal with continuous integration and how to use DbUnit in conjunction with JUnit to control the test environment end-to-end by setting up the state of the database before each test.
Also available in: Japanese  
Articles 13 Apr 2004
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
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
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
Extend Java apps to mobile and cloud
Tips, considerations, best practices, and encouragement for extending existing Java-based enterprise transaction systems and systems of record to mobile applications deployed in cloud environments.
Also available in: Chinese   Japanese  
Articles 04 May 2016
Improving performance and scalability for IBM Sterling Order Management
This article discusses the design best practices that are important for the performance and scalability of the IBM Sterling Order Management solution. Adopting these design best practices during implementation, helps eliminate the common performance bottlenecks that are introduced with custom design or code.
Also available in: Russian   Portuguese  
Articles 07 Aug 2014
Faster problem solving in Java with heuristic search
Learn about the field of heuristic search and its application to artificial intelligence. This article's authors show how they arrived at a successful Java implementation of the most widely used heuristic search algorithm. Their solution exploits an alternative framework to Java Collections and uses best practices for avoiding excessive garbage collection.
Also available in: Chinese   Russian   Japanese  
Articles 16 Jul 2013
Agile DevOps: Test-driven infrastructure
Few in the software industry question that writing automated tests for application code is a good practice. Teams are now applying similar automated testing practices to infrastructure and environments. In this Agile DevOps installment, DevOps expert Paul Duvall covers writing automated tests for your infrastructure using tools such as Cucumber with Gherkin. These tests can be run in conjunction with every scripted change to the infrastructure to ensure quick feedback when a change introduces an error into an environment.
Also available in: Russian   Japanese  
Articles 06 Nov 2012
Manage the topology with virtual system patterns
In the IBM PureApplication System environment, a virtual system pattern is the critical element that allows a user to rapidly set up and manage the cloud middleware topology; a virtual system pattern describes a middleware topology and employs the tools to automatically build that topology in the cloud. IBM PureApplication System virtual system patterns are the captured essence of years of infrastructure-management experience and best practices. Virtual system patterns encapsulate repeatable topology definitions based on various middleware images and runtime configurations; they give you control over the middleware landscape being deployed. In this article, the authors introduce you to virtual system patterns and their place in the ecosystem, describe their components and functions, and provide a basic look at how to create and use a virtual system pattern.
Also available in: Chinese   Russian   Japanese  
Articles 11 Apr 2012
Manage application services with virtual application patterns
In the IBM PureApplication System environment, a virtual application pattern is the critical element that allows a user to rapidly set up and manage cloud application infrastructure; a virtual application pattern describes an application, and employs the tools to build the appropriate infrastructure for the application and then deploys the application to that infrastructure. IBM PureApplication System virtual application patterns are the captured essence of years of application-infrastructure-deployment experience and best practices. Virtual application patterns encapsulate optimized solutions of multiple middleware elements to host specific types of application workloads. In this article, the authors introduce you to virtual application patterns and their place in the ecosystem, describe their components and functions, and provide a basic look at how to create and use a virtual application pattern.
Also available in: Chinese   Russian   Japanese  
Articles 11 Apr 2012
Java web services: Understanding and modeling WSDL 1.1
Several years after the approval of Web Services Description Language (WSDL) 2.0 as a World Wide Web Consortium (W3C) standard, WSDL 1.1 is still the most widely used form of web service description. Despite its popularity, WSDL 1.1 has some issues, including a variety of schemas in use and variations in how web services stacks process WSDL documents. In this article you'll learn how WSDL 1.1 service descriptions are structured. You'll also see the basic structure of a Java tool for verifying WSDL documents and transforming them into a "best practices" form.
Also available in: Chinese   Russian   Japanese   Portuguese  
Articles 08 Feb 2011
Introducing Spring Roo, Part 1: Building from source
Spring Roo is a lightweight productivity tool for Java technology that makes it fast and easy to develop Spring-based applications. Applications created using Spring Roo follow Spring best practices and are based on standards such as JPA, Bean Validation (JSR-303), and Dependency Injection (JSR-330). Roo offers a usable, context-aware, tab completing shell for building applications. Spring Roo is extensible and allows add-ons, enhancing its capability. This article introduces Spring Roo and provides step-by-step instructions on building Spring Roo source on Windows and *nix systems.
Also available in: Russian   Japanese   Portuguese  
Articles 10 Apr 2012
Introduction to Java programming, Part 1: Java language basics
Get an introduction to the structure, syntax, and programming paradigm of the Java language and platform in this two-part tutorial. Learn the Java syntax that youre most likely to encounter professionally and Java programming idioms you can use to build robust, maintainable Java applications. In Part 1, master the essentials of object-oriented programming on the Java platform, including fundamental Java syntax. Get started with creating Java objects and adding behavior to them, and conclude with a summary of Java coding best practices.
Also available in: Chinese   Japanese   Portuguese   Spanish  
Tutorial 24 Aug 2017
Debugging and testing Swing code
When you need to use or maintain other Java developers' code, debugging and testing can help you understand how it works. In the case of visual code though, these powerful practices are more difficult unless you have the appropriate tools. The two open source tools that this article introduces - Swing Explorer and FEST-Swing - can make debugging and testing of Swing UIs simple and reliable. Alex Ruiz shows how to use them to understand a UI's structure, test how it functions, and troubleshoot issues.
Also available in: Chinese   Russian   Japanese  
Articles 02 Feb 2010
In pursuit of code quality: Adventures in behavior-driven development
Test-driven development (TDD) is a great idea in practice, but some developers just can't get over the conceptual leap associated with that word test. In this article, learn about a more natural way to integrate the momentum of TDD into your programming practice. Get started with behavior-driven development (BDD) (via JBehave) and see for yourself what happens when you focus on program behaviors, rather than outcomes.
Also available in: Chinese   Russian   Japanese  
Articles 18 Sep 2007
Automation for the people: Continuous feedback
Feedback is vital for the practice of Continuous Integration (CI) -- in fact, it's the life blood of a CI system. Rapid feedback enables speedy responses to build events that require attention. Without feedback mediums like e-mail or RSS, builds in a broken state have the tendency to stay broken, which defeats the purpose of CI in the first place! In this installment of Automation for the people, automation expert Paul Duvall examines various feedback mechanisms that you can incorporate into CI systems.
Articles 14 Nov 2006
Automation for the people: Remove the smell from your build scripts
How much time do you spend maintaining project build scripts? Probably much more than you'd expect or would like to admit. It doesn't have to be such a painful experience. Development automation expert Paul Duvall uses this installment of Automation for the people to demonstrate how to improve a number of common build practices that prevent teams from creating consistent, repeatable, and maintainable builds.
Also available in: Chinese   Russian  
Articles 10 Oct 2006
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
Ajax for Java developers: Build dynamic Java applications
The page-reload cycle presents one of the biggest usability obstacles in Web application development and is a serious challenge for Java developers. In this series, author Philip McCarthy introduces a groundbreaking approach to creating dynamic Web application experiences. Ajax (Asynchronous JavaScript and XML) is a programming technique that lets you combine Java technologies, XML, and JavaScript for Java-based Web applications that break the page-reload paradigm.
Also available in: Russian  
Articles 20 Sep 2005
J2EE pathfinder: Filtering with Java Servlets 2.4
The Servlet API has long been the cornerstone of enterprise application development, but Servlet filters are a relatively new addition to the J2EE family. In this final article in the J2EE pathfinder series, author Kyle Gabhart introduces you to the Servlet filter architecture, defines the many uses of filters, and walks you through the three steps of a typical filter implementation. He also spills the beans on some of the exciting changes you can expect from the just-released Java Servlet 2.4 specification.
Also available in: Japanese  
Articles 27 Jan 2004
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
Ajax for Java developers: Java object serialization for Ajax
If you're doing JavaWeb development using Asynchronous JavaScript and XML (Ajax), then delivering data from the server to the client is probably your top concern. In this second article in the Ajax for Java developers series, Philip McCarthy walks you through five approaches to Java object serialization and gives you all the information you need to choose the data format and technology best suited to your application.
Articles 04 Oct 2005
1 - 94 of 94 results
Show Summaries | Hide Summaries