 |
|
|
|
|
|
Introdução a Programação Java
A zona de tecnologia Java do developerWorks contém centenas de artigos, tutoriais, dicas e recursos de comunidade para ajudar os desenvolvedores de software a tirarem o máximo proveito da plataforma Java e de tecnologias relacionadas. Mas, quando quando você está procurando um lugar para iniciar, examinar cuidadosamente o volume de recursos disponíveis na Web atualmente pode ser cansativo. O developerWorks oferece esta página para fornecer uma visão geral de noções básicas de tecnologia Java com o texto geral da linguagem. Ela inclui pontos de partida para investigação adicional em forma de links para o conteúdo de introdução relevante do developerWorks, outros recursos educacionais e downloads e produtos IBM.
|
|
|
|
28 Aug 2006 |
|
| |
New to Java programming
The developerWorks Java technology zone contains hundreds of articles, tutorials, tips, and community resources to help software developers make the most of the Java platform and related technologies. But when you're looking for a place to get started, sifting through the volume of resources available on the Web today can be overwhelming. developerWorks offers this page to provide an overview of Java technology basics within the overall context of the language. It includes starting points for further investigation in the form of links to relevant introductory developerWorks content, other educational resources, and IBM downloads and products.
|
|
|
|
28 Aug 2006 |
|
| |
New to Java technology
The developerWorks Java technology zone contains hundreds of articles, tutorials, and tips to help software developers make the most of the Java platform and related technologies. But when you're looking for a place to get started, sifting through the volume of resources available on the Web today can be overwhelming. developerWorks offers this page to provide an overview of Java technology basics within the overall context of the language. It includes starting points for further investigation in the form of links to relevant introductory developerWorks content, other educational resources, and IBM downloads and products.
|
|
|
|
26 Sep 2006 |
|
| |
Configuring and using XA transactions with WebSphere MQ V6 Classes for Java
This article shows you how to configure and use XA distributed transactions with WebSphere MQ Classes for Java,
and how to resolve common problems you may encounter.
|
|
Articles |
|
18 Jan 2006 |
|
| |
Get the message?
This article outlines how to use Java Messaging System (JMS) for large-scale file replication. Dan Drasin describes a solution to an Applied Reasoning customer's distributed data problems, and provides implementation details for a JMS-based solution. He discusses the advantages, some potential pitfalls, and practical instructions for successfully setting up IBM MQSeries (now called WebSphere MQ) as a JMS server.
|
|
Articles |
|
01 Feb 2002 |
|
| |
Mastering Ajax, Part 2: Make asynchronous requests with JavaScript and Ajax
Most Web applications use a request/response model that gets an entire HTML page from the server. The result is a back-and-forth that usually involves clicking a button, waiting for the server, clicking another button, and then waiting some more. With Ajax and the XMLHttpRequest object, you can use a request/response model that never leaves users waiting for a server to respond. In this article, Brett McLaughlin shows you how to create XMLHttpRequest instances in a cross-browser way, construct and send requests, and respond to the server.
|
|
Articles |
|
17 Jan 2006 |
|
| |
Call SOAP Web services with Ajax, Part 2: Extend the Web services client
Implement a Web Browser-based SOAP Web services client using the Asynchronous JavaScript and XML (Ajax) design pattern. In the Part 1 of this series, "Call SOAP Web Services with Ajax, Part 1," the author introduced a simple Web browser-based JavaScript library for invoking SOAP Web services. In the discussion that follows, the author expands on functions of that JavaScript library by implementing basic support for the Web Services Addressing Language and the Web Services Resource Framework specifications.
|
|
Articles |
|
10 Jan 2006 |
|
| |
Secure Java apps on Linux using MD5 crypt
UNIX/Linux PAM-compatible systems use authentication based on the GNU MD5 extensions to the crypt() system call. This article explains these extensions and shows you a Java implementation of MD5 crypt that is compatible with UNIX/Linux systems.
|
|
Articles |
|
10 Jan 2006 |
|
| |
Create VoiceXML pages within a Java Web developer framework
Brett McLaughlin shows you how to output VoiceXML from server-side Java code, allowing your Java applications to interact with telephony.
|
|
Articles |
|
17 Jan 2006 |
|
| |
In tune with Tapestry, Part 2
The Tapestry framework allows Java and Web developers
to develop servlet-based Web applications that are dynamic, lightweight,
and responsive. Continue getting to know Tapestry this month, as Brett
McLaughlin shows you how to plan the development of a Tapestry application
and create useful, robust Tapestry components.
|
|
Articles |
|
10 Jan 2006 |
|
| |
Designing mobile Web services
From when to choose mobile Web services to the overall design guidelines to the value types to use in mobile Web services, this article addresses many of the design considerations you need to ponder when developing Web services for mobile devices. It also covers many of the best practices for designing mobile Web services. Learn how to decide when to use Web services, what things to consider when you design Web services, and what to keep in mind when planning mobile Web services.
|
|
Articles |
|
03 Jan 2006 |
|
| |
Implement MVC in custom SWT components
Eclipse SWT (Standard Widget Toolkit) offers an extensive set of APIs to implement your custom-made widgets. In this article, the author briefly outlines the MVC (Model-View-Controller) architecture, explains the current implementation of MVC in the form of structured viewers, and shows an implementation using a custom SWT widget.
|
|
Articles |
|
11 Jan 2006 |
|
| |
Practical data binding: XPath as data binding tool, Part 2
Once you understand XPath syntax and location paths, accessing XML without the overhead of DOM and SAX is possible and even easy. Fortunately for Java developers, the Java API for XML Processing (JAXP) provides a native Java solution for creating XPath requests and using the results in your applications. In this article, the second in a two-part series, you'll learn how to create an XPath request, execute that request, and work with the resulting node set -- all within a comfortable Java environment.
|
|
Articles |
|
04 Jan 2006 |
|
| |
Deploy J2EE applications on Apache Geronimo
Learn how to deploy JavaServer Pages (JSPs), servlets, and different Enterprise JavaBeans (EJBs) on Apache Geronimo. This article includes the deployment steps required for Apache Geronimo, which are different from other Java 2 Platform, Enterprise Edition (J2EE) containers.
|
|
Articles |
|
03 Jan 2006 |
|
| |
A gentle introduction to SWT and JFace, Part 4: How to use ToolBars and SashForms
This installment of A gentle introduction to SWT and JFace expands on what you've learned about creating applications using Java technology, Eclipse, and the SWT and JFace libraries. This installment shows you how to use ToolBars, CoolBars, Trays, SashForms, Links, and other controls, as well as several dialog types.
|
|
Articles |
|
20 Dec 2005 |
|
| |
Practically Groovy: SwingBuilder and the Twitter API, Part 2
In this Practically Groovy article, Scott Davis continues building the Groovy Twitter client named Gwitter that he began in Part 1. This time, he tackles HTTP Basic authentication and use of Groovy's ConfigSlurper to read in configuration settings.
|
|
Articles |
|
17 Nov 2009 |
|
| |
Effective database testing with IBM Rational Functional Tester 6.1
This article is for developers or testers interested in testing a database directly from their IBM Rational Functional Tester scripts. The information is explained using examples and detailed instructions.
|
|
Articles |
|
10 Nov 2005 |
|
| |
Thanks for the memory
Running out of Java heap isn't the only cause of a java.lang.OutOfMemoryError. If native memory runs out, OutOfMemoryErrors that your normal debugging techniques won't be able
to solve can occur. This article explains what native memory is, how the Java runtime
uses it, what running out of it looks like, and how to debug a native OutOfMemoryError
on AIX. A companion article covers the same topics for Linux and Windows systems.
|
|
Articles |
|
21 Apr 2009 |
|
| |
Introduction to the eSWT mobile extension, Part 1: Use simple widgets to quickly build mobile applications
As mobile platforms become increasingly sophisticated, the demand for
mobile computing will increase. In this series, learn about the embedded Standard Widget Toolkit
(eSWT). You can use eSWT to develop native-looking Java applications for a
variety of mobile phones. This article explores how to use eSWT mobile controls.
Code examples walk you through using five of the classes in the eSWT mobile
extension.
|
|
Articles |
|
15 Sep 2009 |
|
| |
Use Sun SPOTs as your build canary
Find out how to turn a new, open source wireless device -- Sun's Small Programmable Object Technology (SPOT) -- into a highly visible indicator of the health of a Continuous Integration build. Craig Caulfield introduces you to Sun SPOTs and the SPOT SDK, then shows how to use SPOTs as an early-warning system for CruiseControl builds.
|
|
Articles |
|
03 Nov 2009 |
|
| |
AOP@Work: Check out library aspects with AspectJ 5
AspectJ 5's new language and deployment features make
library aspects easy, and library aspects in turn promise to put AOP in
the hands of mere mortals. Miraculously simple to use, they can be
devilishly difficult to write. In this installment of AOP@Work series, Wes Isberg weaves a
tale about 30 serious contenders in a world not too far from your
own; along the way, you'll learn how to use and write library aspects
and how to deliver solutions to believers and nonbelievers alike.
|
|
Articles |
|
17 Jan 2006 |
|
| |
The Servlet API and NIO: Together at last
Think it's impossible to combine NIO and the Servlet API? Think again. In this article, Java developer Taylor Cowan shows you how to apply the producer/consumer model to consumer nonblocking I/O, thus easing the Servlet API into a whole new compatibility with NIO. In the process, you'll see what it takes to build an actual Servlet-based Web server that implements NIO; and you'll find out how that server stacks up against a standard Java I/O server (Tomcat 5.0) in an enterprise environment.
|
|
Articles |
|
03 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.
|
|
Articles |
|
27 Jan 2004 |
|
| |
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.
|
|
Articles |
|
27 Jan 2004 |
|
| |
Distributed transactions with WS-AtomicTransaction and JTA
The aim of this article is to introduce Web Services Transaction (WS-Transaction) concepts and its interaction with transaction services, specifically the J2EE transactional model, Java Transaction API (JTA). It references WebSphere Application Server in its examples and describes an interoperability scenario recently shown at a technology demo hosted by Steve Mills and Bill Gates.
|
|
Articles |
|
27 Jan 2004 |
|
| |
Equipping SWT applications with content assistants
For users of the Eclipse Java editor, content assistants are a well-known feature. You can easily add this feature to any SWT-based application, either a stand-alone application or a plug-in to the Eclipse workbench.
|
|
Articles |
|
19 Nov 2003 |
|
| |
J2ME 101, Part 3: Inside the Record Management System
MIDP does not use a filesystem to save application data. Rather, MIDP stores all information in non-volatile memory, using a storage system called the Record Management System (RMS). In In this article, the first in a two-part companion series to the J2ME 101 tutorial series, author and developer John Muchow introduces the basics of the RMS application interface, then walks you through several development examples that illustrate its functionality.
|
|
Articles |
|
12 Dec 2003 |
|
| |
J2EE pathfinder: Java security with JAAS and JSSE
Kyle Gabhart introduces the Java Authentication and Authorization Service (JAAS) and the Java Secure Socket Extension (JSSE). Follow along to find out how these two APIs combine to provide the core functions of the J2EE Web application security framework: authentication, authorization, and transport-level security.
|
|
Articles |
|
25 Nov 2003 |
|
| |
Java theory and practice: Garbage collection in the HotSpot JVM
Brian Goetz examines how the 1.4.1 JVM actually handles garbage collection, including some of the new garbage collection options for multiprocessor systems.
|
|
Articles |
|
25 Nov 2003 |
|
| |
Lock down J2ME applications with Kerberos, Part 1: Introducing Kerberos data formats
Users need assurance that the wireless applications they use won't compromise their sensitive information. One way to do that is to use industry-standard protocols like Kerberos to provide security. In this series, Faheem Khan will build a sample J2ME MIDlet that uses Kerberos to protect financial data. In this first article of the series, he lays the foundation by explaining the Kerberos data formats that will provide the backbone for his application's security.
|
|
Articles |
|
28 Oct 2003 |
|
| |
Magic with Merlin: Dynamic event listener proxies
Java 1.4 introduces the EventHandler class, which relies on the dynamic generation of listeners to ease the task at hand. Though the new features are typically meant for the IDE vendor to use, in this article columnist John Zukowski shows you how you can use them for hand coding, too.
|
|
Articles |
|
21 Oct 2003 |
|
| |
Lock down J2ME applications with Kerberos, Part 2: Authoring a request for a Kerberos ticket
In the last article in this series, you saw the outlines of a J2ME application that can connect securely to a Kerberos-enabled server; you also learned the details of how Kerberos encryption works at the byte level. This article gets into the meat of the application itself. You'll see how to use the J2ME's facilities and some open source libraries to perform surprisingly powerful encryption routines.
|
|
Articles |
|
25 Nov 2003 |
|
| |
Navigate the JNDI maze
EJB developer Daniel Would explains how you can write client code that successfully finds its way to an EJB component published in a JNDI namespace. He shows you various programming options that make the process easier, and offers some code that you can use as a utility class in your own applications.
|
|
Articles |
|
18 Nov 2003 |
|
| |
Magic with Merlin: Indeterminate progress bars
Developers use a JProgressBar component to show users how far along a task has progressed. For really long tasks or those where it's difficult to figure out exactly how far along that task is, the Merlin release adds an indeterminate mode to JProgressBar. This month, columnist John Zukowski provides a refresher on using JProgressBar and discusses its new indeterminate mode.
|
|
Articles |
|
18 Nov 2003 |
|
| |
Remote scripting servlet in action
This article presents a Web-based incoming-call monitor for a Customer Service Representative (CSR) in a Customer Relationship Management, or CRM, product based on Erik Hatcher's work, "Remote scripting using a servlet." To take that a step further, Victor Yang here analyzes those requirements and looks into such design options as why IFRAME is recommended over XML-RPC. Finally, he'll show you how to customize the original framework while explaining the key issues that take place during implementation with the code snippets.
|
|
Articles |
|
11 Nov 2003 |
|
| |
Scheduling recurring tasks in Java applications
All manner of Java applications commonly need to schedule tasks for repeated execution. However, the standard scheduling classes, Timer and TimerTask, are not flexible enough to support the range of scheduling tasks typically required. In this article, Tom White shows you how to build a simple, general scheduling framework for task execution conforming to an arbitrarily complex schedule.
|
|
Articles |
|
04 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.
|
|
Articles |
|
28 Oct 2003 |
|
| |
Build and implement a single sign-on solution
It is particularly difficult to bolt a single sign-on solution -- SSO, the ability to log in once and be authenticated to all your network resources -- onto existing applications, but every developer faces this problem when building sophisticated portals. Because portals need to integrate with back-end resources, each with its own authentication needs, the portal often has to provide the appearance of single sign-on to the user. In this article, Chris Dunne provides a step-by-step description of his experience with building a single sign-on solution for a Web portal. He shows you how to set up an open source solution, the Central Authentication Service from Yale University, and how to extend it to authenticate to a Microsoft Active Directory infrastructure.
|
|
Articles |
|
30 Sep 2003 |
|
| |
J2EE pathfinder: Implement JSP custom tags in five easy steps
Kyle Gabhart introduces the basics of JSP custom tags and takes you through the five-step process of incorporating them into your JSP pages.
|
|
Articles |
|
22 Oct 2003 |
|
| |
Using Aspects to autonomic-enable legacy applications
Learn how to use Aspects to generate Common Base Events in any legacy Java application, without modifying the original application source. This article shows you how and also provides an example framework that can be used with your applications today.
|
|
Articles |
|
29 Mar 2005 |
|
| |
Store objects using the Preferences API
This article offers an introduction to the Preferences API, a lightweight, cross-platform persistence API introduced in JDK 1.4 and designed to store small amounts of data. Greg Travis explains how objects are stored, demonstrates the process in action, and provides a code library to do the work.
|
|
Articles |
|
14 Oct 2003 |
|
| |
JAR files revealed
Most Java programmers are familiar with basic operations on JAR files. But few programmers are aware of the power of the JAR file format. In this article, the authors explore the many features and benefits of the JAR format, including packaging, executable jar files, security, and indexing.
|
|
Articles |
|
09 Oct 2003 |
|
| |
Eclipse and HSQLDB: Embedding a relational database server into Eclipse, Part 1
This article shows how to develop a plug-in that embeds the HSQLDB pure-Java relational database server into the Eclipse Workbench. Although not as powerful as DB2 and not as popular as MySQL, HSQLDB (the hypersonic SQL database) can satisfy the needs of a wide range of Java applications, because of its extensibility and low memory/processor requirements.
|
|
Articles |
|
30 Sep 2003 |
|
| |
Advanced DAO programming
J2EE developers use the Data Access Object (DAO) design pattern to separate low-level data access logic from high-level business logic. Implementing the DAO pattern involves more than just writing data access code. In this article, Java developer Sean C. Sullivan discusses three often overlooked aspects of DAO programming: transaction demarcation, exception handling, and logging.
|
|
Articles |
|
07 Oct 2003 |
|
| |
Create internationalized JSP applications
Designing Java Server Pages (JSP) applications for an international audience is more of an art than a science, involving much more than meets the eye. The key to success is to understand the unique server-side problems associated with internationalization. Java developer Sing Li clarifies the key problem and presents two solutions based on tried-and-true techniques.
|
|
Articles |
|
29 Mar 2005 |
|
| |
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.
|
|
Articles |
|
23 Sep 2003 |
|
| |
Magic with Merlin: SpringLayout manager
The newly introduced SpringLayout manager offers an alternative when designing complex screens, allowing components to be positioned relative to one another. In this article, Merlin veteran John Zukowski shows you how to use this new layout manager.
|
|
Articles |
|
17 Sep 2003 |
|
| |
Java programming dynamics, Part 4: Class transformation with Javassist
Java consultant Dennis Sosnoski takes a look at Javassist, the bytecode manipulation library that's the basis for the aspect-oriented programming features being added to the widely used JBoss application server. You'll find out the basics of transforming existing classes with Javassist and see both the power and the limitations of this framework's source code approach to classworking.
|
|
Articles |
|
16 Sep 2003 |
|
| |
Discover key features of DOM Level 3 Core, Part 2
In this two-part article, the authors present some of the key features brought by the W3C Document Object Model (DOM) Level 3 Core Working Draft and show you how to use them with examples in Java code. In this second part, they cover operations on the document, access to type information, and introduce you to the early implementation of this API in the Apache Xerces2 project.
|
|
Articles |
|
26 Aug 2003 |
|
| |
Discover key features of DOM Level 3 Core, Part 1
In this two-part article, the authors present some of the key features brought by the W3C Document Object Model (DOM) Level 3 Core Working Draft and show you how to use them with examples in Java code. This first part covers manipulating nodes and text, and attaching user data onto nodes.
|
|
Articles |
|
19 Aug 2003 |
|
| |
Simplify enterprise Java authentication with single sign-on
Faheem Khan shows you how to implement single sign-on (SSO) functionality on the Java platform. You'll see how you can use the GSS-API and Kerberos standards to abstract away some of the difficulty, and implement an SSO-based architecture with relative ease.
|
|
Articles |
|
09 Sep 2003 |
|
| |
Access USB devices from Java applications
Java technology's platform independence makes the process of writing Java applications that interact with hardware quite tricky. In this article, research scientist Qingye Jiang examines two projects that are making the process easier by providing APIs through which Java applications can make use of USB devices.
|
|
Articles |
|
02 Sep 2003 |
|
| |
J2EE pathfinder: The many uses of implicit objects
In this follow-up to last month's introduction to session scopes, Java enterprise expert Kyle Gabhart delves into the many uses of JSP implicit objects. Follow along as he introduces the nine implicit objects, explains the purpose (and multiple purposes) of each one, and closes with a list of best practices for using these handy little workers in your JSP programming efforts.
|
|
Articles |
|
26 Aug 2003 |
|
| |
Assess Java RAS functions directly
This article is for developers working with the IBM(R) Virtual Machine for Java(TM) (JVM), predominately on z/OS(R). Following practical examples, learn how to use the Java Virtual Machine Reliability Accessibility Serviceability Interface (JVMRI) to inject signals directly into JVM. Follow along as Richard Cole gives a simple example of how you can use JVMRI to get dumps out of JVM. Find out how the agent works, how to compile it and load it into the JVM, how the trigger for this agent works, and how to run the trigger to get a dump.
|
|
Articles |
|
24 Feb 2005 |
|
| |
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.
|
|
Articles |
|
21 Aug 2003 |
|
| |
Magic with Merlin: Formatting numbers and currency
With the Merlin release of the J2SE platform, internationalizing your applications when formatting integers has gotten simpler, and you can now find out the ISO 4217 currency codes. In this month's Magic with Merlin column, John Zukowski shows you how to format numbers and introduces the new support for discovering local currency codes.
|
|
Articles |
|
13 Aug 2003 |
|
| |
Build interoperable Web services with JSR-109
JSR-109 facilitates the building of interoperable Web services in the Java 2 Platform, Enterprise Edition (J2EE) environment. It standardizes the deployment of Web services in a J2EE container. This article discusses the server and client programming models defined by JSR-109 and provides code examples.
|
|
Articles |
|
05 Aug 2003 |
|
| |
Magic with Merlin: The ins and outs of Merlin's new I/O buffers
In this Magic with Merlin article, resident Java programming wizard John Zukowski shows how to manipulate the data buffers underlying the J2SE new I/O packages, for such tasks as reading/writing primitives and working with memory-mapped files.
|
|
Articles |
|
25 Mar 2003 |
|
| |
Roll your own distributed management solution
Noam Camiel describes an alternative to Enterprise JavaBeans technology: Distributed Services Management (DSM) is a homegrown development environment that runs over RMI. It's simple, lightweight, and easy to learn.
|
|
Articles |
|
18 Mar 2003 |
|
| |
A JSTL primer, Part 2: Getting down to the core
Mark Kolb continues his exploration into the JSP Standard Tag Library (JSTL) and the core library with a look at tags to assist with flow control and URL management.
|
|
Articles |
|
18 Mar 2003 |
|
| |
Getting started with JML
The Java Modeling Language (JML) is a notation for detailed design that encourages a new way of thinking about methods and classes. In this primer, Java programming consultant Joe Verzulli introduces JML and some of its most important declarative constructs.
|
|
Articles |
|
18 Mar 2003 |
|
| |
Sharing code with the Eclipse Platform
Get an overview of how the Eclipse Platform supports source-code version
control in software projects. We begin with a brief discussion about the ideas for team
code development, then see how Eclipse works with CVS code repositories. We'll also
look at some of the source-code management software tools supported through Eclipse plug-in extensions.
|
|
Articles |
|
13 Mar 2003 |
|
| |
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.
|
|
Articles |
|
22 Mar 2005 |
|
| |
Demystifying Extreme Programming: Winning with a pair
In this article, Roy Miller talks about the XP practice of pair programming, a radical way to write code. He covers the misconceptions surrounding pairing, why so many software developers hate it, and why it's so important to your project's success.
|
|
Articles |
|
11 Mar 2003 |
|
| |
Diagnosing Java code: Java generics without the pain, Part 2
Eric Allen continues the discussion of generic types in JSR-14 and Tiger. He outlines several limitations imposed in those Java extensions and explains how the limitations are necessitated by the implementation strategy used by the compilers of these extended languages.
|
|
Articles |
|
11 Mar 2003 |
|
| |
Real-time Java, Part 4: Real-time garbage collection
Nondeterministic pauses in traditional garbage collection (GC) have inhibited Java technology from being a suitable environment for real-time (RT) development. Metronome GC -- part of IBM WebSphere Real Time -- provides deterministic GC behavior that, when combined with other features, enables developers to write hard RT applications in the Java language. The authors describe the approach that Metronome uses for deterministic GC, technical issues involved in developing Metronome, and the tools and facilities available for tuning GC.
|
|
Articles |
|
02 May 2007 |
|
| |
Using the Eclipse GUI outside the Eclipse Workbench, Part 3: Adding actions, menus, and toolbars
In this third and final article in this "Using the Eclipse GUI outside the
Eclipse Workbench" series, A.O. Van Emmenis completes the file explorer example by
adding actions, menu bars, pop-up menus, and toolbars. He shows how to set menu
item properties, how to reuse actions in menus and toolbars, and how to make
actions context-sensitive by listening to events from viewers. The example actions
use utilities to launch programs and access the system clipboard.
|
|
Articles |
|
04 Mar 2003 |
|
| |
Mastering Ajax, Part 5: Manipulate the DOM
Last month Brett introduced the Document Object Model, whose elements work behind the scenes to define your Web pages. This month he dives even deeper into the DOM. Learn how to create, remove, and change the parts of a DOM tree, and take the next step toward updating your Web pages on the fly!
|
|
Articles |
|
11 Apr 2006 |
|
| |
Using Java platform management beans
The latest release of the Java platform includes a number of new system monitoring and management features. In this article, three developers from the IBM Java Technology Centre team up to get you started using this API. After a quick overview of the java.lang.management package, they guide you through a number of short practical scenarios to probe the performance of a running JVM.
|
|
Articles |
|
11 Apr 2006 |
|
| |
AOP@Work: Component design with Contract4J
Design by Contract is a proven technique for clarifying component design details, documenting proper usage for clients, and testing usage compliance programmatically. In this final article in the AOP@Work series, Dean Wampler introduces Contract4J, a Design by Contract tool that specifies contracts using Java 5 annotations and evaluates them at run time using AspectJ aspects. Along with being a strong addition to your AOP toolkit, Contract4J offers insight into emerging trends in aspect-oriented design.
|
|
Articles |
|
11 Apr 2006 |
|
| |
A stepped approach to J2EE testing with SDAO
The Data Access Object pattern has become a standard part of the J2EE developer's arsenal. Now, simulated data access objects brings together the best of DAO, mock objects, and layered testing. Enterprise Java developer (and resident SDAO guru) Kyle Brown uses code samples and discussion to guide you through the concepts and everyday use of SDAO.
|
|
Articles |
|
04 Mar 2003 |
|
| |
Using the Eclipse GUI outside the Eclipse Workbench, Part 2: Using the JFace image registry
In this article, A.O. Van Emmenis continues with the example started in Part 1
of this "Using the Eclipse GUI outside the Eclipse Workbench" series.
He cleans up the content and label providers and shows how to use sorting and
filtering on JFace viewers. He shows how to add a status line to the window, add
icons to both viewers, and save system resources by using the JFace image registry.
|
|
Articles |
|
14 Feb 2003 |
|
| |
Practically Groovy: MVC programming with Groovy templates
Views are an integral part of MVC programming, which is itself a ubiquitous
component of enterprise application development. In this installment of Practically Groovy, Andrew Glover shows how Groovy's template engine framework can simplify view programming and make your code more maintainable over time.
|
|
Articles |
|
15 Feb 2005 |
|
| |
Taming Tiger: Get pane relief with Tiger
How many times have you written code with frame.getContentPane().add(), or forgotten to get the content pane before calling add() and ended up with an Error thrown at runtime? As consultant John Zukowski shows you in this Taming Tiger tip, these problems are a thing of the past.
|
|
Articles |
|
15 Feb 2005 |
|
| |
J2EE pathfinder: J2EE technologies for the stateful network
Both Java servlets and Enterprise JavaBeans components provide stateful server-side processing in J2EE. To help you choose the right solution for your enterprise, LearningPatterns Senior Mentor Kyle Gabhart compares the two technologies and evaluates their performance in some common stateful application scenarios.
|
|
Articles |
|
04 Mar 2003 |
|
| |
J2EE pathfinder: J2EE technologies for the stateless network
The J2EE pathfinder series offers a window into one or more J2EE technologies, often weighing several of them to help you make informed decisions. In this first installment in the series, LearningPatterns Senior Mentor Kyle Gabhart compares two J2EE technologies for the stateless network: servlets and EJB technology.
|
|
Articles |
|
01 Feb 2003 |
|
| |
Magic with Merlin: Java networking enhancements
John Zukowski shows you what's new and different in Java technology networking, including the latest networking features in J2SE 1.4, IPv6 support, URIs, network interfaces, secure sockets, and unbound sockets.
|
|
Articles |
|
25 Feb 2002 |
|
| |
Java theory and practice: 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.
|
|
Articles |
|
18 Feb 2003 |
|
| |
A JSTL primer, Part 1: The expression language
In this article, software engineer Mark Kolb shows you how to use the JSP Standard Tag Library (JSTL) to avoid using scripting elements in your JSP pages. You'll learn how to simplify software maintenance by removing source code from the presentation layer. And you'll learn about JSTL's simplified expression language.
|
|
Articles |
|
11 Feb 2003 |
|
| |
Preparing for the Mobile Application Developer Certification
Learn how to become certified as a Java 2 Platform, Micro Edition (J2ME) mobile developer, an achievement that is recognized by peers and managers looking for experienced mobile developers. Getting ready requires knowledge of a lot of topics, though, and this article, presented by one of the designers of the certification, introduces you to these requirements.
|
|
Articles |
|
15 Feb 2005 |
|
| |
Extend J2ME to Wireless Messaging
The objective of wireless messaging is to extend the networking and I/O capabilities of J2ME applications to send and receive messages using the messaging services on GSM networks, like Short Message Wevice (SMS) and Cell Broadcast Service (CBS).
|
|
Articles |
|
04 Feb 2003 |
|
| |
Demystifying Extreme Programming: Focusing on value
Your XP team needs to understand how to interact with the project sponsors (the people who pay for the software) in a way that speaks their language, but doesn't compromise the principles XP tells us are important. This month, Roy Miller excerpts and adapts material from his upcoming book, Growing Software: Exploding the Myth of Prediction and Control, to tell you how.
|
|
Articles |
|
01 Feb 2003 |
|
| |
Using the Eclipse GUI outside the Eclipse Workbench, Part 1: Using JFace and SWT in stand-alone mode
Although the Eclipse GUI components (JFace and SWT) are often used
inside the Eclipse Workbench, they were designed as self-contained frameworks
in their own right. Even outside the Eclipse Workbench, JFace's pluggable
design still allows you to develop sophisticated GUIs with surprisingly little
code. In this "Using the Eclipse GUI outside the Eclipse Workbench" series, you
can learn how to build just such a stand-alone application. Part 1 starts with a Hello World
example and builds, step by step, into a simple file explorer. Get acquainted
with some of the major JFace classes (and a few SWT widgets), along with
tips, tricks, and design issues.
|
|
Articles |
|
23 Jan 2003 |
|
| |
XML and Java technologies: Data binding, Part 2: Performance
Enterprise Java expert Dennis Sosnoski checks out the speed and memory usage of several frameworks for XML data binding in Java, including the JAXB standard, Castor mapped binding, and others.
|
|
Articles |
|
01 Jan 2003 |
|
| |
EJB best practices: Build a better exception-handling framework
Enterprise applications are often built with little attention given to exception handling, which can result in over-reliance on low-level exceptions such as java.rmi.RemoteException and javax.naming.NamingException. In this article, Brett McLaughlin explains why a little attention goes a long way when it comes to exception handling, and shows you two simple techniques that will set you on the path to building more robust and useful exception handling frameworks.
|
|
Articles |
|
01 Jan 2003 |
|
| |
EJB best practices: Validation helper classes
Well-designed validation procedures can increase data integrity, ensure your applications run smoothly, and make future changes in data easier to handle. In this edition of EJB best practices, Brett McLaughlin expands upon the validation techniques discussed in the last tip, and improves upon the initial concepts.
|
|
Articles |
|
01 Jan 2003 |
|
| |
Diagnosing Java code: Design for easy code maintenance
This month, Eric Allen explains how avoiding and controlling gratuitous mutation is key to retaining code robustness while making the code easier to maintain. He focuses on such concepts as functional style code crafting and ways of marking fields, methods, and classes to handle and prevent mutability. Also, Eric explains the role of unit testing and refactoring in this task, and offers two tools to aid in refactoring efforts.
|
|
Articles |
|
01 Jan 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.
|
|
Articles |
|
01 Jan 2003 |
|
| |
Mobile P2P messaging, Part 2: Develop mobile extensions to generic P2P networks
Generic peer-to-peer computing networks such as JXTA and Jabber are often too complex for mobile devices. Thus, lightweight mobile clients or special architectures that work through relays are needed to extend those P2P communities to mobile users. In this second part of our series on mobile peer-to-peer messaging, Michael Yuan discusses JXME, a J2ME JXTA client project. We'll examine the examples bundled in the JXME distribution to show you how to use the JXME APIs. In addition, we will also briefly discuss options to develop mobile Jabber applications.
|
|
Articles |
|
01 Jan 2003 |
|
| |
From black boxes to enterprises, Part 3: Hands-on JMX integration
In this third and final article of the JMX series, Sing Li will use an actual Network Management System (NMS) to monitor a Java application instrumented with JMX, revealing the typical techniques used in NMS/JMX integration, as well as some of the common difficulties that may be encountered when deploying JMX.
|
|
Articles |
|
17 Dec 2002 |
|
| |
JavaCC, parse trees, and the XQuery grammar, Part 2
Part 1 of this article took an introductory look at grammars, parsers, and BNF. It then introduced JavaCC, a popular parser generator. Part 2 shows you how to modify the sample code in Part 1 so that you can use an additional tool, JJTree, to build a parse tree representation of the same parse. You'll explore the advantages of this approach and look at how to write Java code to walk the parse tree at runtime in order to recover its state information, and evaluate the expression being parsed. The article concludes by showing you how to develop a generalizable routine for walking and evaluating a parse tree that you'll generate from a small portion of the XQuery grammar.
|
|
Articles |
|
01 Dec 2002 |
|
| |
JavaCC, parse trees, and the XQuery grammar, Part 1
After a brief discussion of grammars, parsers, and BNF, this article introduces JavaCC, a popular parser generator tool. You'll develop sample code that uses JavaCC to build a custom parser, starting from a BNF description of the grammar. Part 2 goes on to show how to use an auxilliary tool, JJTree, to build a parse tree representation of the same parse and how to walk that tree at runtime to recover its state information. The article concludes by developing sample code to build and walk a parse tree that you'll generate for a small portion of the XQuery grammar.
|
|
Articles |
|
01 Dec 2002 |
|
| |
EJB best practices: The fine points of data validation
Brett McLaughlin explains some of the concepts behind data validation on EJB technology-based systems, and shows you how to avoid unexpected or incomprehensible error messages.
|
|
Articles |
|
01 Dec 2002 |
|
| |
Crossing borders: Domain-specific languages in Active Record and Java programming
The Java programming world is full of domain-specific languages (DSLs), but options in the Java language for building DSLs are limited. Not so with Ruby. In this article, you'll learn some nifty ways Ruby lets you integrate clean DSLs, giving you a new frame of reference for examining your Java options with open eyes.
|
|
Articles |
|
04 Apr 2006 |
|
| |
Multithreaded unit testing with ConTest
Concurrent programming is notoriously bug-prone. Worse, concurrent bugs tend to be detected late in the development process when they cause considerable damage and are hard to debug. Even when they are done thoroughly, conventional unit-testing practices are likely to miss concurrent bugs. In this article, concurrency experts Shmuel Ur and Yarden Nir-Buchbinder explain why concurrent bugs are so hard to catch and present a new solution from IBM Research.
|
|
Articles |
|
04 Apr 2006 |
|
| |
Diagnosing Java code: Assertions and temporal logic in Java programming
Although traditional assertions can increase the amount of checking that can be done over Java code, there are many checks you just can't perform with them. One way to fill this gap is with temporal logic, a formalism used to describe how a program state will change over time. In this article, Eric Allen discusses assertions, introduces temporal logic, and describes a tool for processing temporal logic assertions in your programs.
|
|
Articles |
|
01 Jul 2002 |
|
| |
Magic with Merlin: Swing's new JFormattedTextField component
Accepting formatted input doesn't have to be difficult with input verifiers and focus listeners, as this article shows.
|
|
Articles |
|
01 Jun 2002 |
|
| |
Internationalizing your Eclipse plug-in, Part 1: How to write Eclipse plug-ins for the international market
In this roadmap for writing Eclipse plug-ins destined for the international market, we begin with a brief review of the motivations and technical challenges of internationalization, followed by step-by-step instructions for internationalizing your plug-in. We then examine how these steps were applied to the internationalization of the Eclipse Platform, itself.
|
|
Articles |
|
01 Jun 2002 |
|
| |
Diagnosing Java code: The case for static types
Many popular languages -- such as Ruby, Python, and other so-called scripting languages -- have moved away from static type checking as a means to help improve the reliability of code. Still, static type checking can be one of the key weapons in a powerful arsenal against introducing and for detecting bugs. In this article, Eric Allen makes a case for static type checking, explains why we should be glad that the Java language supports it, and discusses how it can be made even better.
|
|
Articles |
|
01 Jun 2002 |
|
| |
Java theory and practice: Safe construction techniques
Concurrent programming in Java applications is more complicated than it looks: there are several subtle (and not so subtle) ways to create data races and other concurrency hazards in Java programs. In this installment of Java theory and practice, Brian Goetz looks at a common threading hazard: allowing the this reference to escape during construction. This harmless-looking practice can cause unpredictable and undesirable results in your Java programs.
|
|
Articles |
|
01 Jun 2002 |
|
| |
