Home    Consulting    Research   Mentoring    Training    Speaking    Writing    About    Contact


Books by Ted Neward



White Papers


Java Papers

Slicing and Dicing J2EE

Part 1 of the Oracle "Mastering J2EE Application Development" series

Read Paper Here >>  

An article I wrote for Oracle's OTN, describing five different types of applications that enterprise developers work on, and how J2EE and related enterprise Java technologies address each one.

The Busy Java Developer's Guide to db4o: Introduction and overview

Learn to love the OODBMS all over again

Read Paper Here >>  

It has been said that the database wars are over and the relational database won. However, anyone who believes this state of affairs has led to peace and prosperity among programmers hasn't tried using a relational database to back Java objects lately. Part 1 of an in-depth, multipart series introducing db4o, an object-oriented alternative to today's relational databases.

The Busy Java Developer's Guide to db4o

Read Paper Here >>  

Links to the complete series.

The Busy Java Developer's Guide to db4o: Queries, updates and identity

Read Paper Here >>  

Whereas the RDBMS uses SQL as its principal mechanism for finding and retrieving data, an OODBMS can use one of several different mechanisms. In this second installment of his series, I introduce a few of the options, including Query by Example and custom mechanisms unique to the OODBMS. As I explains, some of the alternatives can be easier to use than SQL itself.

The Busy Java Developer's Guide to db4o: Database refactoring with db4o

Read Paper Here >>  

Refactoring Java code is far simpler than refactoring a relational database, but fortunately that isn't so much the case with object databases. In this installment of The busy Java developer's guide to db4o, Ted Neward introduces you to yet another advantage of his favorite object database: db4o simplifies refactoring to the point where it's almost trivial.

The Busy Java Developer's Guide to db4o: Structured objects and collections

Read Paper Here >>  

Object-oriented applications make considerable use of inheritance, and they frequently want to use that inheritance (or "is-a") relationship to categorize and organize objects within a given system. This can prove difficult in a relational storage scheme, which has no intrinsic concept of inheritance, but in an OODBMS, it's a core feature. In this installment of The busy Java developer's guide to db4o, discover the surprising ease (and power) of using inheritance as a core feature when creating queries in db4o.

The Busy Java Developer's Guide to db4o: Arrays and collections

Read Paper Here >>  

Collections and arrays introduce new levels of complexity to the structured objects first discussed in The busy Java developer's guide to db4o: Beyond simple objects. Fortunately, db4o isn't the least bit fazed by handling multiplicity relationships -- and neither should you be.

The Busy Java Developer's Guide to db4o: Beyond simple objects

Read Paper Here >>  

So far, creating objects and manipulating them in db4o looks pretty easy -- maybe a little too easy, in fact. In this article, db4o enthusiast Ted Neward shows you what happens when simple objects become structured ones (that is, objects that reference objects) and issues like infinite recursion, cascading behavior, and referential integrity come into play.

Using the BootClasspath

Tweaking the Java Runtime API

Read Paper Here >>   Download Code   Download Paper   

Many Java programmers don't realize it, but the Java Runtime Environment is an amazingly configurable environment-so much about the Java execution environment can be controlled via options either on the command-line or through the JNI Invocation interface. One such option is the ability to define the location of the Java "bootstrap" classes-java.lang.Object, java.lang.Exception, and so forth-to come from someplace other than the ubiquitous "rt.jar" file in the "jre/lib" directory. In fact, we can use this non-standard JVM option to subvert the Java environment in many powerful ways, giving Java programmers a tremendous amount of power over their environment. But with power comes complexity, and this is no exception: it's powerful, but only if you're willing to accept the risks that go along with it.

Finding Loaded Classes

Know What Code You're Executing

Read Paper Here >>   Download Code   Download Paper   

Understanding what version of your code is executing in production can be the difference between a solved bug and an embarrassing admission of ignorance. Too many times developers are caught up defending code that isn't properly migrated out to Production or a customer's machine. In some extreme cases, developers (and/or tech support staff) are expected to support code on client machines with no idea of precisely what version of the code is running there. Add to this mess the usual variety of patches, minor version releases and daily builds, and you have a recipe for complete disaster, both from a personal and professional standpoint. One of the common means to address this problem, coming to us from the C/C++ world, is to embed a string in a compiled object file, which then gets loaded into the compiled executable. "In the field", developers and/or tech support staff can run a utility (usually the Unix "strings" command or some variant thereof) to see the exact versions of each .C/.CPP file used to build the code the customer is currently running. Unfortunately, because Java doesn't support static linking, the same approach doesn't work for us; however, we can adapt it (through one of two ways) to provide much the same level of support.


When "java.policy" Just Isn't Good Enough

Read Paper Here >>   Download Code   Download Paper   

Java 2's security system is a complex, pluggable architecture that allows for Java programmers to participate in the default process, or to replace the java.policy-based implementation altogether in favor of something else. In fact, Sun favors this latter approach, urging developers to implement a customized Policy implementation more suitable to their business' needs. In this paper, we will examine the details of how a new Policy implementation is built, and provide readers with the knowledge necessary to "roll your own" Java Security Policy implementations. This paper assumes you are familiar, at least in concept, with some of the Java2 Security architecture.

Java statics

When is a static not static?

Read Paper Here >>   Download Code   Download Paper   

Java programmers, like C++ programmers, expect that static instances (namely, static fields) are unique within the JVM. While true for most Java code, the real story behind the "static" keyword is more complex than that. What's worse, it can rear its head to bite Java programmers in very sensitive areas in complex environments like a servlet container or EJB server.

Multiple Java Homes

Giving Java Apps Their Own JRE

Read Paper Here >>   Download Code   Download Paper   

With the exponential growth of Java as a server-side development language has come an equivablent exponential growth in Java development tools, environments, frameworks, and extensions. Unfortunately, not all of these tools play nicely together under the same Java VM installation. Some require a Servlet 2.1-compliant environment, some require 2.2. Some only run under JDK 1.2 or above, some under JDK 1.1 (and no higher). Some require the "com.sun.swing" packages from pre-Swing 1.0 days, others require the "javax.swing" package names. Worse yet, this problem can be found even within the corporate enterprise, as systems developed using Java from just six months ago may suddenly "not work" due to the installation of some Java Extension required by a new (seemingly unrelated) application release. This can complicate deployment of Java applications across the corporation, and lead customers to wonder precisely why, five years after the start of the infamous "Installing-this-app-breaks-my-system" woes began with Microsoft's DLL schemes, we still haven't progressed much beyond that. (In fact, the new .NET initiative actually seeks to solve the infamous "DLL-Hell" problem just described.) This paper describes how to configure a Java installation such that a given application receives its own, private, JRE, allowing multiple Java environments to coexist without driving customers (or system administrators) insane.


.NET Papers

Comparing LINQ and Its Contemporaries

Read Paper Here >>  

Project LINQ addresses object-relational mismatch problems by elevating relations and queries to first-class concepts within language semantics and library-based extensions. Project LINQ offers a degree of type safety and static type checking lacking in most, if not all, forms of object-to-relation persistence found in use today in managed runtime environments such as .NET, Java, or J2EE containers.

Hosting ASP.NET

Running ASP.NET code in an all-managed HTTP Server

Read Paper Here >>   Download Code   Download Paper   

Despite the wide popularity of ASP.NET (also known as the HTTP Pipeline), not well known is the fact that the HTTP Pipeline can be hosted in any .NET application, through the under-documented System.Web.Hosting namespace, part of the System.Web assembly. This paper discusses the API of the System.Web.Hosting classes, and how to host the HTTP Pipeline in your own code.


Platform-Agnostic Papers

The Vietnam of Computer Science

The quagmire that is Object/Relational Mapping

Read Paper Here >>  

Avoiding the Quagmire

A follow-up paper to "The Vietnam of Computer Science" commissioned by ODMG.org on how an OODBMS can avoid some of the pitfalls of the Object/Relational mapping quagmire.

Read Paper Here >>  

Multi-Core Mythbusters

Read Paper Here >>  

An article I co-authored for DevX (with Rogue Wave's Cory Isaacson) describing the myths of multi-core CPUs and Java app servers. Even though the article targeted Java app servers, the concepts are pretty universal and applicable to any application server (.NET, Java, or otherwise). And, for those who are curious, yes, the reference to the "trying the Diet Coke and Mentos trick in your kitchen" is a true story... but not in my kitchen, it was a friend of mine, I swear....

.NET and Java: A Study in Interoperability

Read Paper Here >>  

Java and .NET are both great platforms on their own, but together, they are a practical necessity in the modern enterprise. With enterprise development market share of 35-40% each, it's fairly obvious that neither of these two platforms is "going away" any time soon. It's clear to even the most zealous Java or .NET devotee that working with both platforms is going to become the norm. This article looks at various interoperability issues between the Java and .NET platforms.

Pragmatic Architecture: Introduction

Read Paper Here >>  

Introduction to the "Pragmatic Architecture" series; contains links to the rest of the series

Pragmatic Architecture: Layering

Read Paper Here >>  

Rethinking n-tier, and why that's a good thing

Pragmatic Architecture: Security

Read Paper Here >>  

What, exactly, does "secure" mean, from an architectural perspective?

Pragmatic Architecture: User Interface

Read Paper Here >>  

Ajax, RIAs, "fat" clients, oy! It's enough to drive an architect mad....


Use XML to write papers

Read Paper Here >>   Download Code   Download Paper   

Having authored a number of papers, I've begun to run into the pain and agony of having to write while fighting with my chosen composition environment (that is, MSWord) and how to format things. For example, getting fonts and paragraph settings configured just the way I like them, standardizing on heading titles, and so on. I realize that I probably don't use the tool (again, MSWord) to a fraction of its complete capability, but I face a difficult choice: learn the tool in order to master it, and consume valuable time I could be writing, or simply live with the shortcomings of my ignorance and keep focused on the technologies I care about. Fortunately, another solution presented itself in the form of a tool written by DevelopMentor for use in its internal projects. Conceptually, it's a simple idea- -capture all content in XML, then render it into the medium desired (Word, PowerPoint, LaTEX, and so on) via tools. I was fortunate enough to be one of the early adopters, and was so enamored of the system that I immediately set out to see if I could replicate success by adopting something similar for my own use in writing papers.


home  |  about  |  consulting  |  speaking  |  mentoring  |  research  |  writing  |  contact


Copyright © 2006 Neward & Associates. All rights reserved.