 |
|
|
|
|
|
Scott Davis on rebooting the Practically Groovy series
Scott Davis, author, speaker, software developer, founder of ThirstyHead.com, a Groovy and Grails training company, joins to talk about rebooting the Practically Groovy series on developerWorks. His Groovy: A DSL for Java Programmers is highlighted this week.
|
|
Articles |
|
18 Feb 2009 |
|
| |
Practically Groovy: Groovy: A DSL for Java programmers
Groovy expert Scott Davis reboots the Practically Groovy series, dormant since 2006. This initial installment catches you up on Groovy's recent history and the current state of the Groovy union. Then you'll learn how easy it is to get started with Groovy, circa 2009.
|
|
Articles |
|
17 Feb 2009 |
|
| |
Automation for the people: Deployment-automation patterns, Part 2
Java deployments are often messy, error-prone, and manual, leading to delays in making software available to users. In Part 2 of this two-part article, automation expert Paul Duvall expands on a collection of key patterns for developing a reliable, repeatable, and consistent deployment process capable of generating one-click deployments for Java applications.
|
|
Articles |
|
10 Feb 2009 |
|
| |
The busy Java developer's guide to Scala: Explore Scala concurrency
The "gateway drug" to Scala for many, if not most, Java
programmers is the promise of easier coding when dealing with concurrency
and writing thread-safe code. In this installment, Ted Neward begins to dive
into the various concurrency features and libraries provided by the Scala
language and environment.
|
|
Articles |
|
04 Feb 2009 |
|
| |
Transaction strategies: Understanding transaction pitfalls
Transaction processing should achieve a high degree of data integrity
and consistency. This article, the first in a series on developing an effective transaction strategy for the Java platform, introduces
common transaction pitfalls that can prevent you from reaching this goal. Using code examples from the Spring Framework and the Enterprise JavaBeans (EJB) 3.0 specification, series author Mark Richards explains these all-too-common mistakes.
|
|
Articles |
|
03 Feb 2009 |
|
| |
Generate DITA Java API reference documentation using DITADoclet
and DITA API specialization
Combine DITADoclet and DITA API specialization to save time and still produce quality API documentation directly from the Java source code.
|
|
Articles |
|
03 Feb 2009 |
|
| |
Essential Java resources
The Java platform will be celebrating its 14th birthday soon and one side-effect when a successful and ubiquitous language reaches this kind of milestone is the widespread proliferation of libraries, tools, and ideas -- this bonus can leave many newcomers to the Java language adrift in a sea of material. In this article, the author (a solid contributor to that overwhelming sea) tacks through the vast tides and presents a list of the key resources any up-and-coming Java developer should have.
|
|
Articles |
|
23 Jan 2009 |
|
| |
Mastering Grails: Give your Grails applications a facelift
In this installment of Mastering Grails, Scott Davis demonstrates how to make drastic changes to the look and feel of a Grails application using Cascading Style Sheets (CSS), templates, tag libraries (TagLibs), and more.
|
|
Articles |
|
20 Jan 2009 |
|
| |
Java's new math, Part 2: Floating-point numbers
Join Elliotte Rusty Harold for a look into "new" features in the classic java.lang.Math class in this two-part article. Part 1 focuses on more purely mathematical functions. Part 2 explores the functions designed for operating on floating-point numbers.
|
|
Articles |
|
13 Jan 2009 |
|
| |
Automation for the people: Deployment-automation patterns, Part 1
Java deployments are often messy, error-prone, and manual, leading to delays in making software available to users. In Part 1 of a two-part article in the Automation for the people series, automation expert Paul Duvall identifies a collection of key patterns for developing a reliable, repeatable, and consistent deployment process capable of generating one-click deployments for Java applications.
|
|
Articles |
|
13 Jan 2009 |
|
| |
Groovier Spring, Part 1: Integration basics
The Spring Framework provides a solid foundation for Web and enterprise applications. Spring's support for dynamic languages like Groovy adds capabilities that can make your application architecture more flexible and dynamic. In Part 1 of this two-part series, you'll learn the basics of integrating Groovy into Spring applications.
|
|
Articles |
|
06 Jan 2009 |
|
| |
Groovier Spring, Part 2: Change application behavior at run time
The Spring Framework provides a solid foundation for Web and enterprise applications. Spring's support for dynamic languages like Groovy adds capabilities that can make your application architecture more flexible and dynamic. In the second and final installment of the Groovier Spring series, you'll learn how to change the behavior of Spring applications at run time using dynamically refreshable beans.
|
|
Articles |
|
06 Jan 2009 |
|
| |
The busy Java developer's guide to Scala: Scala and servlets
If Scala is a fully JVM-compatible language, then you should be able
to use it in various "real-world" environments such as one in which you build servlets
and other Web applications. In this article, the author explores using Scala in a servlet
environment.
|
|
Articles |
|
22 Dec 2008 |
|
| |
JavaScript EE, Part 1: Run JavaScript files on the server side
Combine JavaScript with Java code on the server to get the freedom to use the
same JavaScript routines on both servers and clients. In addition, the
techniques presented throughout this series will allow you to maintain a
single code base for both Ajax and non-Ajax clients. Because much of the
server-side code would still be written in the Java language, you'll find it
necessary to expose the Java Platform, Enterprise Edition (Java EE) features to JavaScript. In this series, learn
how to run JavaScript files on the server side, call remote JavaScript
functions with Ajax, and use the Java Scripting API with the JavaServer Pages
(JSP) technology.
|
|
Articles |
|
16 Dec 2008 |
|
| |
Stop writing so much code!
Write less code by leveraging a battle-hardened collection of open source utilities from the Apache Commons project's Lang library. Reusing other people's reliable code helps you get your software to market more quickly, with fewer defects.
|
|
Tutorials |
|
16 Dec 2008 |
|
| |
Mastering Grails: Grails in the enterprise
In this installment of Mastering Grails, series author Scott Davis puts to rest any qualms about Grails' readiness for the enterprise. You'll see how to use Grails with enterprise-caliber libraries including the Java Management Extensions (JMX), Spring, and log4j.
|
|
Articles |
|
16 Dec 2008 |
|
| |
Prelude to a software profiler: Work you should do before the tool works for you
Today's software profilers do a great job of identifying the
resource-intensive code in your application. It takes a lot more work on your
part,
however, to determine which components need the most tuning to make your
application run faster. In this article, learn about a methodical approach for
efficiently finding the root performance problems. Rein in the
resource hogs, and zero in on the performance pickles that are the most fixable.
|
|
Articles |
|
09 Dec 2008 |
|
| |
Debug Java applications remotely with Eclipse
You don't need to debug Java applications on just your local desktop. Learn how to spread around your debugging using different connection types that make up remote debugging. This article outlines the features and examples that show how to set up remote application debugging.
|
|
Articles |
|
09 Dec 2008 |
|
| |
Dependency injection with Guice
Guice is Google's open source dependency injection framework for Java development. It enables better testing and modularity by taking away the pain of writing your own factories. Nicholas Lesiecki offers a tour of the most important Guice concepts that will leave you ready to Guice up your applications.
|
|
Articles |
|
09 Dec 2008 |
|
| |
Build faster Web applications with caching
Web developers who use Java technologies can quickly improve their applications'
performance by using a cache utility. Java Caching System (JCS), a powerful
distributed caching system for Java applications, is a highly configurable tool with a
simple API. This article gives you an overview of JCS and shows how you can use it to speed up your Web applications.
|
|
Articles |
|
02 Dec 2008 |
|
| |
Building Ajax-enabled JSP TagLib controls, Part 2: Auto-populate and field validator controls
Build Asynchronous JavaScript + XML (Ajax) controls that can be used in
business-line applications. These configurable JavaServer Pages (JSP) TagLib-based controls
leverage JavaScript Object Notation (JSON), JavaScript scripting language, and
Cascading Style Sheets (CSS). Because they are standard JSP TagLib controls, find out how
you can easily drop them into any application to provide more intuitive and responsive user
interfaces.
|
|
Articles |
|
25 Nov 2008 |
|
| |
The busy Java developer's guide to Scala: Building a calculator, Part 3
Domain-specific languages (DSLs) have become a hot topic; much of the buzz around functional languages is their ability to build such languages. After having established both an AST scheme and a basic front-end parser designed to take text and produce a graph of objects suitable for interpretation, in this article the author thinks it's time to wire everything together into a seamless -- if somewhat trivial at this point -- whole. Then he'll turn around and suggest some extensions that could be made to the language and interpreter.
|
|
Articles |
|
25 Nov 2008 |
|
| |
Automation for the people: Wielding wizard-based installers
Installing software is often a painful chore for most users. The installation
package you generate -- the "last mile" of software development -- can make the
difference between user adoption and another product thrown into the virtual waste bin. In this installment of Automation for the people, automation expert Paul Duvall demonstrates how the freely available, open source IzPack tool for writing wizard-based installers can make installing your software a snap for users.
|
|
Articles |
|
25 Nov 2008 |
|
| |
Pointillism meets pixelation
Paul Reiners shows how to animate images in unexpected and artistic ways using the Java 2D API and cellular automata. In the process, he demonstrates implementation of an image operator in Java code and explains cyclic space, a type of 2D cellular automaton. You can use the ideas from this article to create your own image operators and artistic programs using Java technology.
|
|
Articles |
|
18 Nov 2008 |
|
| |
Mastering Grails: Asynchronous Grails with JSON and Ajax
JavaScript Object Notation (JSON) and Asynchronous JavaScript + XML (Ajax) are staples of Web 2.0 development. In this installment of the Mastering Grails series, author Scott Davis demonstrates the native JSON and Ajax capabilities baked into the Web framework.
|
|
Articles |
|
18 Nov 2008 |
|
| |
Create stand-alone Web services applications with Eclipse and
Java SE 6, Part 1: The Web service server application
Use the Eclipse Integrated Development Environment (IDE) and Java
Platform, Standard Edition (Java SE) 6 to create a stand-alone Web services
application that can be run from the console. In this tutorial, the first in a
series, start by getting familiar with the Eclipse IDE. Configure the
environment; create projects, packages, and classes; then run the application
from the command line.
|
|
Tutorials |
|
13 Nov 2008 |
|
| |
Advanced XQuery: Creating custom functions
XQuery functions enable you to define common expressions once and reuse them frequently. The end result is tighter, more robust code that is easier to maintain. Using XQuery API for Java (XQJ), this tutorial demonstrates an implementation of XQuery functions within a Java environment.
|
|
Tutorials |
|
11 Nov 2008 |
|
| |
Drive development with easyb
A disconnect between the stakeholders who define requirements and the developers
who implement them has long plagued software development. In recent years, frameworks
based on dynamic languages and domain-specific languages (DSLs) have tried to bridge
the stakeholder-developer gap by making code read more like normal language. This
tutorial shows how easyb -- which provides a more natural DSL that is closely attuned to stakeholders -- helps developers and stakeholders collaborate effectively.
|
|
Tutorials |
|
05 Nov 2008 |
|
| |
What's new with Apache Solr
Leverage Apache Solr's many new enhancements to add best-in-breed capabilities to your application.
|
|
Articles |
|
04 Nov 2008 |
|
| |
Java's new math, Part 1: Real numbers
Join Elliotte Rusty Harold for a look into "new" features in the classic
java.lang.Math class in this two-part article. Part 1 focuses on more purely
mathematical functions. Part 2 will explore the functions designed for operating on floating-point numbers.
|
|
Articles |
|
28 Oct 2008 |
|
| |
The busy Java developer's guide to Scala: Building a calculator, Part 2
Domain-specific languages (DSLs) have become a hot topic; much of the buzz
around functional languages is their ability to build such languages. In this latest
installment, Ted Neward tackles the problem of transforming
textual input into the AST for interpretation by continuing with a simple calculator DSL
that demonstrates the power of functional languages for building "external" DSLs. To parse
textual input and transform it into the tree structure used by the interpreter in the last
article, Ted introduces "parser combinators," a standard Scala library designed solely for the task. (In the previous article, we built a calculator interpreter and AST.)
|
|
Articles |
|
21 Oct 2008 |
|
| |
Writing great code with the IBM FileNet P8 APIs, Part 1: Hello, Document!
This article gets you started with developing a simple application,
HelloDocument, with the IBM FileNet P8
Content API. Through a sequence of simple operations, learn to use coding patterns
to perform a wide variety of your own operations. The P8 APIs are extensive, and it
can be a little tricky for first-timers to know how to get started. This article
gives you that start: an orientation and launchpad from which you can easily build
your own applications. Even if you are an old hand at P8 development, you will
certainly find useful information in this article and subsequent articles in the
series. Future articles in this series go into more depth on specific topics in both the process and content APIs.
|
|
Articles |
|
16 Oct 2008 |
|
| |
Mastering Grails: Testing your Grails application
Grails makes it easy to ensure that your Web applications start out bug
free and stay that way. As a bonus, you can leverage your test code to produce a rich
set of executable documentation that is always up-to-date. This month, Grails guru Scott Davis shows you the Grails testing ropes.
|
|
Articles |
|
14 Oct 2008 |
|
| |
Cross-platform development with JRuby and Swing
In addition to building Web and console applications with Ruby, you can write complex GUI desktop applications that run unmodified on multiple platforms. Thanks to JRuby, a robust alternative to the traditional C implementation of Ruby, Ruby GUI toolkits can use UI tools available to the Java platform. This article introduces Monkeybars, a library that uses JRuby and Swing for building applications, and takes you through an example application.
|
|
Articles |
|
07 Oct 2008 |
|
| |
Automation for the people: Parallel development for mere mortals
Although many development teams use version-control systems to manage code changes, they can struggle when developers code off the same code base, in parallel. In this Automation for the people installment, automation expert Paul Duvall shows how to effectively tag, branch, and merge source code using the open source, freely available Subversion version-control system.
|
|
Articles |
|
07 Oct 2008 |
|
| |
Enhance performance with class sharing
The latest release of the IBM JRE for Java SE
6 enhances IBM's class sharing feature first introduced in Version 5. In
this article, performance analysts Adam Pilkington and Graham Rawson detail the changes, which
include improvements in application startup times and memory utilisation.
|
|
Articles |
|
30 Sep 2008 |
|
| |
Build configurable workflows with WS-BPEL and IoC, Part 2: Developing and hosting BPEL workflows
In Part 2 of this brief series, Bilal Siddiqui explains how to use BPEL to express the logic of configurable business workflows. You'll learn how to host your BPEL applications on a BPEL engine and make them work in conjunction with an IoC implementation.
|
|
Articles |
|
30 Sep 2008 |
|
| |
Securing a multitenant SaaS application
The multitenant nature of Software as a Service (SaaS) applications makes security an essential concern. This article introduces a viable and practical approach to securing a multitenant Java application with the open source Spring Security framework combined with Apache Directory Server. The authors present a multitenant example Web application to demonstrate this approach.
|
|
Articles |
|
30 Sep 2008 |
|
| |
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.
|
|
Articles |
|
23 Sep 2008 |
|
| |
Mastering Grails: RESTful Grails
We live in the era of mashups. Creating Web pages that give users the information they
want is a good start, but offering a source of raw data that other Web developers can
easily mix in with their own applications is better. In this installment of Mastering Grails, Scott Davis introduces various ways to get Grails to produce XML instead of the usual HTML.
|
|
Articles |
|
16 Sep 2008 |
|
| |
Create a Java applet to download information in remote Web services
Start with a Java applet and build a server-based
proxy system that uses your browser to access an arbitrary Web service. You'll use
JavaScript code to access applet-based information and call a servlet, which retrieves
the remote information. Thus, you bypass the same-server restrictions on what an
applet can and cannot do.
|
|
Articles |
|
04 Sep 2008 |
|
| |
Efficient data transfer through zero copy
This article explains how you can improve the performance of I/O-intensive Java applications running on Linux and UNIX platforms through a technique called zero copy. Zero copy lets you avoid redundant data copies between intermediate buffers and reduces the number of context switches between user space and kernel space.
|
|
Articles |
|
02 Sep 2008 |
|
| |
Dynamically manage XML schema variations in XMLBeans applications
Apache XMLBeans does not inherently support multiple versions of an XML
schema. For applications that need this type of support to manage
compatibility, this limitation is serious. But there is a solution, and in
this article, you'll learn how dynamic class loading techniques can help.
|
|
Articles |
|
26 Aug 2008 |
|
| |
The busy Java developer's guide to Scala: Building a calculator, Part 1
Domain-specific languages have become a hot topic; much
of the buzz around functional languages is their applicability to build such
languages. In this installment, Ted Neward starts building
a simple calculator DSL that demonstrates the power of functional languages for
building "external" DSLs. Toward that end, he explores a new feature of Scala,
case classes, and revisits an old functional friend, pattern matching.
|
|
Articles |
|
26 Aug 2008 |
|
| |
The Java XPath API
Elliotte Rusty Harold demonstrates Java 5's new XPath API.
|
|
Articles |
|
25 Aug 2008 |
|
| |
Customize JAX-RPC Web services and clients with advanced tools
This tutorial takes you beyond the basics of the JAX-RPC and shows how to customize your JAX-RPC Web services and clients with the help of Apache Axis. On the client side, you can autogenerate much of the code required to connect with new JAX-RPC Web services, focusing your time on the interactions themselves rather than on routine Web service calls. On the server side, you can add additional options, limit the methods you expose, and restrict parameters you'll accept. All of this is possible with a little customization and a deeper understanding of the Apache Axis toolset.
|
|
Tutorials |
|
19 Aug 2008 |
|
| |
Java run-time monitoring, Part 3: Monitoring performance and availability of an application's ecosystem
The third and final installment in this series on run-time monitoring of Java
applications focuses on strategies and techniques for monitoring the performance and availability of an application's supporting and dependent services. These include the underlying host operating system, the operational database, and messaging infrastructures. The article concludes with a discussion of performance data management issues and data reporting and visualization.
|
|
Articles |
|
12 Aug 2008 |
|
| |
Mastering Grails: The Grails event model
Everything in Grails, from build scripts to individual artifacts such as domain classes and controllers, throw events at key points during an application's life cycle. In this Mastering Grails installment, you'll learn how to set up listeners to catch these events and react to them with custom behavior.
|
|
Articles |
|
12 Aug 2008 |
|
| |
Automation for the people: Hands-free database migration
Databases are often out of sync with the applications they support, and getting the database and data into a known state is a significant challenge to manage. In this installment of Automation for the people, automation expert Paul Duvall demonstrates how the open source LiquiBase database-migration tool can reduce the pain of managing the constant of change with databases and applications.
|
|
Articles |
|
05 Aug 2008 |
|
| |
Java run-time monitoring, Part 2: Postcompilation instrumentation and performance monitoring
Part 1 of this three-part series on run-time monitoring of Java applications focuses on the JVM's health and ways to instrument source code to capture performance metrics. This second installment presents techniques for instrumenting Java classes and constructs without modifying the original source code.
|
|
Articles |
|
05 Aug 2008 |
|
| |
Ajax and Java development made simpler, Part 4: Create JSF-like components, using JSP tag files
JavaServer Pages (JSP) and JavaServer Faces (JSF) used to have different variants
of the Expression Language (EL). Their unification in JSP 2.1 opened new possibilities,
allowing you to use deferred values and deferred method attributes in your custom JSP
tags. This article shows how to develop Java Web components based on JSP tag files,
which are much simpler and easier to build than the JSF components.
|
|
Articles |
|
29 Jul 2008 |
|
| |
Java run-time monitoring, Part 1: Run-time performance and availability monitoring for Java systems
Run-time performance monitoring is critical to achieving and maintaining a well-performing system. In this article, the first in a three-part series, Nicholas Whitehead explains how to do low-level granular monitoring of Java performance efficiently. The data you generate can provide valuable insights into system operation and reveal constraints and influences that affect an environment's stability and performance.
|
|
Articles |
|
29 Jul 2008 |
|
| |
The busy Java developer's guide to Scala: Packages and access modifiers
Code has to be referenced and packaged in the real world, and in this installment of his series, Ted Neward covers Scala's package and access modifier facilities before continuing to explore of the functional side of Scala by examining the "apply" mechanism.
|
|
Articles |
|
29 Jul 2008 |
|
| |
Using the Ruby Development Tools plug-in for Eclipse
This article introduces using the Ruby Development Tools (RDT) plug-in for Eclipse, which allows Eclipse to become a first-rate Ruby development environment. Ruby developers who want to learn how to use the rich infrastructure of the Eclipse community to support their language will benefit, as will Java developers who are interested in using Ruby.
|
|
Articles |
|
24 Jul 2008 |
|
| |
Use XStream to serialize Java objects into XML
XML serialization has a myriad of uses, including object persistence and data transport. However, some XML-serialization technologies can be complex to implement. XStream is a lightweight and easy-to-use open source Java library for serializing Java objects to XML and back again. Learn how to set up XStream, and discover how to use it to serialize and deserialize objects as well as to read configuration properties from an XML configuration file.
|
|
Articles |
|
23 Jul 2008 |
|
| |
Deal with errors in XML parsing
XML parsing is a part of nearly every enterprise application. Error handling, though, is absent from most of those same applications. Learn how to use the Simple API for XML (SAX) to deal with errors in your XML parsing -- even if your applications are using the DOM, JAXP, or another API to deal with XML.
|
|
Articles |
|
22 Jul 2008 |
|
| |
Build a RESTful Web service
Representational state transfer (REST) is a style of designing loosely coupled applications that rely on named resources rather than messages. The hardest part of building a RESTful application is deciding on the resources you want to expose. Once you've done that, using the open source Restlet framework makes building RESTful Web services a snap. This tutorial guides you step-by-step through the fundamental concepts of REST and building applications with Restlets.
|
|
Tutorials |
|
22 Jul 2008 |
|
| |
Ajax and Java development made simpler, Part 3: Build UI features based on DOM, JavaScript, and JSP tag files
In the first part of this series, you saw how to generate JavaScript code for sending Ajax requests and processing Ajax responses. The second part showed how to create HTML forms, using conventions and JSP tag files to minimize setup and configuration. In this third part of the series, you'll learn how to develop client-side validators based on JavaScript as well as server-side validators, which are implemented as JSP tag files backing up their JavaScript counterparts. You'll also learn how to use resource-bundles that are reloaded automatically when changed, without requiring the restart of the application.
|
|
Articles |
|
22 Jul 2008 |
|
| |
Mastering Grails: Grails and legacy databases
In this Mastering Grails installment, Scott Davis explores the various ways that Grails can use database tables that don't conform to the Grails naming standard. If you have Java classes that already map to your legacy databases, Grails allows you to use them unchanged. You'll see examples that use Hibernate HBM files and Enterprise JavaBeans 3 annotations with legacy Java classes.
|
|
Articles |
|
15 Jul 2008 |
|
| |
Build an RPC service and client using JAX-RPC
Remote procedure calls (RPCs) are the precursors to modern Web services
that are based on the Simple Object Access Protocol (SOAP) or Representational State
Transfer (REST). Because all of the Java platform's Web service APIs are built on the concepts introduced in RPC, understanding the Java APIs for XML-Based RPC (JAX-RPC) is an almost mandatory step for writing efficient and effective Web services in the Java language. This tutorial takes you through getting and installing JAX-RPC, configuring it, and building a server-side RPC receiver and a simple client-side application.
|
|
Tutorials |
|
15 Jul 2008 |
|
| |
Evaluating XPaths from the Java platform
XPath makes selecting elements, attributes, and text in an XML document easy.
Learn how to evaluate XPaths from Java programming, and work with the returned nodes.
|
|
Articles |
|
08 Jul 2008 |
|
| |
Build configurable workflows with WS-BPEL and IoC, Part 1: Understanding dynamic business workflows
Inversion of Control (IoC) and Web Services Business Process Execution Language (WS-BPEL) can be effective tools for implementing dynamic business workflows. In this article, the first in a two-part series, Bilal Siddiqui describes business workflows' dynamic nature and proposes a two-layer workflow model that lets you use XML to build configurable and flexible solutions.
|
|
Articles |
|
08 Jul 2008 |
|
| |
Automation for the people: Continual refactoring
Refactoring is a well-accepted practice for improving existing code.
Yet, how do you find the code that should be refactored, in a consistent and
repeatable manner? In this installment of Automation
for the people, you'll learn how to use static analysis tools to identify code smells to refactor, with examples showing how to improve odiferous code.
|
|
Articles |
|
08 Jul 2008 |
|
| |
IBM Data Studio pureQuery Runtime for z/OS Performance
In this article, get a brief overview of pureQuery technology, the enhancements announced with Version 1.2, and the results of a performance study comparing pureQuery access methods with a variety of popular Java data access alternatives.
|
|
Articles |
|
08 Jul 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.
|
|
Articles |
|
01 Jul 2008 |
|
| |
The busy Java developer's guide to Scala: Collection types
Objects have their place in Scala, but so do functional types such as tuples, arrays, and lists. In this installment of Ted Neward's popular series, you'll begin to explore the functional side of Scala, starting with its support for types common to functional languages.
|
|
Articles |
|
27 Jun 2008 |
|
| |
Robust Java benchmarking, Part 1: Issues
Program performance is always a concern, even in this era of
high-performance hardware. This article, the first in a two-part series, guides you
around the many pitfalls associated with benchmarking Java code. Part 2 covers the statistics of benchmarking and offers a framework for performing Java benchmarking. Because almost all new languages are virtual machine-based, the general principles the article describes have broad significance for the programming community at large.
|
|
Articles |
|
24 Jun 2008 |
|
| |
Robust Java benchmarking, Part 2: Statistics and solutions
Program performance is always a concern, even in this era of high-performance hardware. This article, the second in a two-part series, covers the statistics of benchmarking and offers a framework you can use to benchmark Java code ranging from self-contained microbenchmarks to code that calls a full application.
|
|
Articles |
|
24 Jun 2008 |
|
| |
Locate specific sections of your XML documents with XPath, Part 2
Part 1 of this tutorial gave you a foundational understanding of XPath. Using slash notation, wildcards, unions, and simple text, you learned how to locate elements and attributes anywhere within an XML document. However, sometimes you need more than just matching based on the name of a node. Predicates give you advanced and refined searching capabilities, allowing you to evaluate the values of attributes and the parent and child nodes of a targeted element. Rather than find a wider node set and refine or filter that set programmatically, you can add predicates to your XPaths to find exactly the nodes you want.
|
|
Tutorials |
|
17 Jun 2008 |
|
| |
Mastering Grails: Grails and the mobile Web
The number of cell phone users worldwide is at 3.3 billion and rising, and Internet access from mobile phones is on a rapidly upward trajectory. Developing for the mobile Web has its unique demands. In this Mastering Grails installment, Scott Davis shows you how to make your Grails applications mobile phone friendly.
|
|
Articles |
|
17 Jun 2008 |
|
| |
Automation for the people: Pushbutton documentation
Project documentation is often one of the necessary evils in delivering a software product. But imagine being able to generate your documentation at the click of a button. In this installment of Automation for the people, automation expert Paul Duvall explains how you can use open source tools to automate the generation of Unified Modeling Language (UML) diagrams, build figures, entity-relationship diagrams (ERDs), and even user documentation.
|
|
Articles |
|
10 Jun 2008 |
|
| |
Locate specific sections of your XML documents with XPath, Part 1
XML is a data format concerned primarily with compatibility and flexibility. But
as useful as XML is, it's limited without the abilities to find specific portions of a
document quickly and to filter and selectively locate data within a document. XPath
provides the ability to easily reference specific text, elements, and attributes within
a document -- and with a fairly low learning curve. Additionally, XPath is key to many other XML vocabularies and technologies, such as XSL and XQuery. This tutorial will teach you the fundamentals of XPath, including all of its various selectors and semantics, in an example-driven and hands-on manner.
|
|
Tutorials |
|
10 Jun 2008 |
|
| |
Reuse Java code in your Ruby on Rails applications
The Ruby Java Bridge (RJB) lets you load Java classes directly
to, and call them from, Ruby on Rails applications. This tutorial shows how you can
put this toolkit to work by reusing your legacy Java Web application code in a modern Web development platform.
|
|
Tutorials |
|
05 Jun 2008 |
|
| |
Embed the NASA World Wind Java SDK in Eclipse
The open source World Wind Java (WWJ) SDK by NASA creates new possibilities for the open Geographic Information Systems (GIS) community. World Wind, a 3D interactive world viewer written in the Java language and OpenGL, lets users zoom from outer space into any place on Earth. This article explains how GIS developers who want to enhance their Eclipse-based applications can embed the WWJ SDK as an Eclipse plug-in.
|
|
Articles |
|
03 Jun 2008 |
|
| |
The busy Java developer's guide to Scala: Implementation inheritance
Scala gives you just as much support for implementation inheritance as
the Java language does -- but Scala's inheritance yields a few surprises. This month, Ted Neward
introduces you to polymorphism done the Scala way, blending functional and
object-oriented language styles while still mapping perfectly to the Java platform's inheritance model.
|
|
Articles |
|
28 May 2008 |
|
| |
Build software with Gant
Gant is a highly versatile build framework that leverages both Groovy and Apache Ant to let you implement programmatic logic while using all of Ant's capabilities. In this tutorial, Andy Glover guides you step-by-step through Gant's fundamental concepts. You'll learn how to define behavior in your build through Gant's flexible domain-specific language, how to reuse Ant features, and how to define functions that make your builds more efficient and even proactive.
|
|
Tutorials |
|
27 May 2008 |
|
| |
Dead like COBOL
With the recent reports of Java's imminent demise, you're
probably wondering if it's time to leave the platform behind for
greener pastures. Before you make a decision, step back and examine the Java ecosystem, along with
that of its competitors, to see if the rumors have any substance. It's time, in other
words, to have a State of the Java Union address, holding neither pride nor prejudice in
the evaluation of the platform.
|
|
Articles |
|
27 May 2008 |
|
| |
Creating business model templates with WebSphere Service Registry and Repository V6.1
Creating new enterprise-specific business models for use within the IBM WebSphere Service Registry and Repository enables your organization to represent your business concepts within WSRR, relate them to other concepts, and manage them using WebSphere Service Registry and Repository's governance capabilities. The default business models demonstrate what you can represent in WebSphere Service Registry and Repository, but how do you create your own models? This article describes how to create, load, update, and use new business models within WebSphere Service Registry and Repository V6.1 without having to use any special tooling.
|
|
Articles |
|
22 May 2008 |
|
| |
Ajax and Java development made simpler, Part 2: Use conventions to minimize setup and configuration
Most Web frameworks try to be as flexible and extensible as possible to accommodate different application needs and development styles. Unfortunately, sometimes this leads to complexity, processing overheads, and large configuration files. This article shows how to use JSP Standard Tag Library (JSTL) and JSP tag files to implement data binding, page navigation, and style conventions, which make both development and maintenance easier. You will learn how to build custom JSP tags with dynamic attributes to facilitate rapid application changes. In addition, the last section of the article contains an example that uses Ajax to submit a Web form.
|
|
Articles |
|
20 May 2008 |
|
| |
Mastering Grails: Grails services and Google Maps
Scott Davis shows you how you can add maps to a Grails application using freely
available APIs and Web services in this latest installment of Mastering
Grails. He uses the trip-planner sample application from previous installments and
takes it to the next level with geocoding, Google Maps, and Grails services.
|
|
Articles |
|
20 May 2008 |
|
| |
Developing long term strategies for using Java EE technology
Changes to technology are inevitable and necessary, and some of these changes could affect how your existing applications operate. Such inevitability might make it seem risky to commit to technologies that are driven by changing specifications, such as Java EE. However, it is possible to minimize the impact of incompatible changes with informed choices and good planning when determining which technologies are appropriate for you to use. This article offers information to help you make those informed choices, and also explains what IBM does to minimize the impact of these changes to your organization.
|
|
Articles |
|
14 May 2008 |
|
| |
Automation for the people: Manage dependencies with Ivy
Managing source-code dependencies among projects and tools is often a burden, but it doesn't need to be. In this installment of
Automation for the people,
automation expert Paul Duvall describes how you can use the Apache Ant project's Ivy dependency manager to handle the myriad dependencies that every nontrivial Java project must manage.
|
|
Articles |
|
06 May 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.
|
|
Articles |
|
06 May 2008 |
|
| |
The busy Java developer's guide to Scala: Of traits and behaviors
Scala doesn't just bring functional concepts to the JVM, it
offers us a modern perspective on object-oriented language design. In this
month's installment, Ted Neward shows you how
Scala exploits traits to make objects simpler and easier to build. As you'll
learn, traits are both similar to and different from the traditional
polarities offered by Java interfaces and C++ multiple
inheritance.
|
|
Articles |
|
29 Apr 2008 |
|
| |
Jenabean: Easily bind JavaBeans to RDF
The Resource Description Framework (RDF) is the World Wide Web
Consortium (W3C) proposed standard for linking and expressing data on the Web.
Java developers who develop applications for the Semantic Web will need to convert RDF properties to or from Java types. Jenabean uses the Jena Semantic Web framework's flexible RDF/OWL API to persist JavaBeans, making the task of writing these applications easier and more familiar to Java developers.
|
|
Articles |
|
29 Apr 2008 |
|
| |
Scala and XML
Scala is a popular new programming language that runs on the Java Virtual Machine (JVM.) Scala compiles into byte-code and thus it can leverage the Java programming language. Its syntax, however, makes it a powerful alternative to Java in certain scenarios. One of those scenarios is XML processing. Scala lets you navigate and process parsed XML in several ways. It also has first class support for XML built right in, so there is no need to create strings of XML or programmatically build DOM trees. In this article, you will see these aspects of Scala in action and see how Scala can make working with XML a joy to do.
|
|
Articles |
|
22 Apr 2008 |
|
| |
Patterns of persistence, Part 2: Increase code reuse and enhance performance
Part 1 of this
two-part article covers the basics of achieving a consistent, concise domain model and persistence tier with modern object-relational mapping (ORM) tools. In Part 2, the authors describe base domain entities, behavior in the domain model, and more-advanced features of a generic DAO. They also share strategies for enhancing data-retrieval performance with the domain model.
|
|
Articles |
|
22 Apr 2008 |
|
| |
Patterns of persistence, Part 1: Strategies and best practices for modern ORM tools
Although many developers use object-relational mapping (ORM) tools for
their applications' persistence tier, some are confused about how to use them and
duplicate code unnecessarily. The authors' experience constructing many persistence
tiers has given them a clear understanding of persistence patterns and best practices.
The first part of this two-part article covers the basics of a consistent, concise
domain model and persistence tier. Part 2 builds and
expands on the concepts covered in this article.
|
|
Articles |
|
22 Apr 2008 |
|
| |
Data binding with Castor, Part 4: Bind your Java objects to SQL databases
Castor allows you to bind the data in your Java objects directly into database
tables. Learn how to marshal from Java objects to SQL in this article.
|
|
Articles |
|
18 Apr 2008 |
|
| |
Mastering Grails: Many-to-many relationships with a dollop of Ajax
Many-to-many (m:m) relationships can be tricky to deal with in a Web
application. In this installment of Mastering Grails, Scott Davis shows you how to
implement m:m relationships in Grails successfully. See how they're handled by the
Grails Object Relational Mapping (GORM) API and the back-end database. Also find out
how a bit of Ajax (Asynchronous JavaScript + XML) can streamline the user interface.
|
|
Articles |
|
15 Apr 2008 |
|
| |
Tapestry and Wicket compared
JSF and Struts are the traditional component frameworks developers turn to for
Web development. You have an alternative, however: Tapestry and
Wicket are component-oriented Web frameworks designed to create Web
applications. A simple example application implementing a to-do list workflow is
developed here, using Tapestry and Wicket technologies.
|
|
Articles |
|
08 Apr 2008 |
|
| |
Spice up collections with generics and concurrency
The Java Collections Framework is an important aspect of the Java platform.
Both desktop and enterprise applications typically collect items to work with. This
article shows you how to work with collections while taking advantage of
enhancements made to the framework in Java SE 6. You can go far beyond HashMap or
TreeSet by using generics and concurrency features to make your applications more
maintainable and scalable.
|
|
Articles |
|
08 Apr 2008 |
|
| |
Automation for the people: Hands-off load testing
Load testing is often relegated to late-cycle activities, but it doesn't
need to be that way. In this installment of Automation for the people, automation
expert Paul Duvall describes how you can discover and fix problems throughout the
development cycle by creating a scheduled integration build that runs JMeter tests.
|
|
Articles |
|
08 Apr 2008 |
|
| |
Ajax and Java development made simpler, Part 1: Generate JavaScript code dynamically with JSP tag files
Many Web developers complain that Java EE is too complex,
building new Web components is difficult, customizing the existing ones is not as
easy as it should be, and minor changes require application restarts. This series presents simple solutions to these problems, using code generators, conventions, scripting languages, and the latest JavaServer Pages (JSP) features. You will learn how to build reusable Ajax and Java components based on JSP tag files, which are very easy to develop and deploy. When changed, JSP tag files are recompiled automatically by the Java EE server without having to restart the application. In addition, you fully control the generated code, and you are able to easily customize these lightweight components because they use the JSP syntax.
|
|
Articles |
|
08 Apr 2008 |
|
| |
Using the SQLXML data type
If you're a Java 2 Enterprise Edition (J2EE) developer, you'll want to preview the SQLXML technology. Check out procedures to create an XML document, store an XML document in a relational database, retrieve an XML document from a database, and navigate an XML document with the SQLXML Java data type.
|
|
Articles |
|
07 Apr 2008 |
|
| |
Securing Java applications with Acegi, Part 5: Protecting JavaBeans in JSF applications
Bilal Siddiqui concludes his series by demonstrating how to use Acegi to
secure access to JavaBeans in Java Server Faces (JSF) applications. You can
configure secure beans in a variety of ways, including using Acegi-secured
inversion-of-control (IOC) beans directly in your JSF tags.
|
|
Articles |
|
01 Apr 2008 |
|
| |
Fluently Groovy
This tutorial is for Java developers unfamiliar with Groovy,
who want a quick and easy introduction to the basics. Get started with Groovy's
simplified variation of the Java syntax and learn about essential features like native
collections, built-in regular expressions, and closures. Write your first Groovy class,
and then see how easily you can use JUnit to test it. You'll walk away from this
one-hour tutorial with a fully functioning Groovy development environment and the skills to use it. Best of all, you'll have learned first-hand how to use Groovy and Java code together in your everyday Java application development.
|
|
Tutorials |
|
26 Mar 2008 |
|
| |
The busy Java developer's guide to Scala: Don't get thrown for a loop!
Scala was written specifically for the Java platform, so its syntax is
designed to make Java coders feel at ease. At the same time, Scala brings to the JVM
the inherent power of functional languages -- and those functional design concepts
take some getting used to. In this installment, Ted Neward starts introducing you to the subtle differences
between the two languages, starting with control constructs such as if, while, and
for. As you'll learn, Scala gives these constructs a power and complexity you won't
find in their Java equivalents.
|
|
Articles |
|
26 Mar 2008 |
|
| |
An introduction to RichFaces
Today's clients want and have begun to expect desktop features in
browser-based applications. RichFaces is one of a new breed of user interface
component suites available for Java Server Faces (JSF). Among other benefits,
RichFaces provides built-in JavaScript and Ajax capabilities to meet those
expectations. Joe Sam Shirah adds some new tools to your kit based on experiences
with a recent field project, including general setup for using RichFaces with
Facelets, and several specific component examples
|
|
Articles |
|
25 Mar 2008 |
|
| |
What's new in the Java Portlet Specification V2.0 (JSR 286)?
Learn all about the second version of the Java Portlet Specification (JSR 286). In Version 2.0, the specification and the APIs more than
doubled, and it allows you to implement most use cases without the need to have vendor extensions. The portlet programming model also provides events and public render parameters so that you can build
larger composite applications out of your portlets and reuse your portlets in different scenarios.
|
|
Articles |
|
18 Mar 2008 |
|
| |
