1. Universities are supposed to fill the niche in the education system in which we train people to lead institutions and invent the future. I don’t want computer science students studying Spring and Scrum (neither of which will be relevant in ten years). I want them inventing new programming languages, I/O devices, and non-Von Neumann CPUs. I want them studying history so that when they are elected to Congress, they won’t act like idiots. I want them studying language, so that when they make speeches, they won’t sound like they’re illiterate. Let the red-brick universities and multi-compass-point institutions teach Scrum and Spring. Universities should be teaching foundational skills that will be relevant for fifty years, and that can’t be easily learned on one’s own.

2. Once upon a time, the implied contract between employers and employees included on-the-job training. Staff were hired on the basis of personality, brains, and initiative, and the specific requirements of the job would be learned on company time. Today every employer wants their staff to be highly trained, but on someone else’s nickel. Why must it be up to the universities? Even if young employees are perfectly launched, they still need to keep current or they will be obsolete in 5-10 years anyway. Universities should equip people with the underlying skills to keep current – a passion for learning, an ability to focus, and a love of reading. Keeping current is an ongoing activity in any case.

3. Current graduates don’t seem to be able to read, write or do math anyway. (Here’s where I stop defending universities.) Seriously, how can anyone get through 16+ years of education and not be able to write? It’s gotten to the point where if I see a business document with no major grammar errors, I say to myself “how refreshing”. That’s very sad. Same for math; a basic knowledge of statistics is helpful in almost any area of business – but try to find someone who knows the difference between mean and median. My point is that if universities are going to do any refocusing at all, it should be on core skills.

So I urge Ivy League schools to go ahead and teach linear algebra and theory of computation and Haskell programming (which I bet we’re all using in five years anyway – seriously- but that’s another blog entry). And make the kids read Shakespeare and Faulkner. When they’re in charge of everything, we’ll be glad of it.

But I also believe in the “when in Rome” principle. As developers, we should try to conform to the spirit and assumptions behind the tools we are using (e.g. nobody will thank you for using Lisp idioms in Java). So if we have to use ClearCase, and the Atria / Rational / IBM people expect us to develop on private branches, maybe we should. Opinions?

Transaction Example

Both transactions are trying to process withdrawals of $100. In either case, if the balance is sufficient, a status message is sent to a downstream system and the balance is reduced. Otherwise the transaction is aborted. If these transactions are run in the serializable isolation level, can they be executed concurrently without fear of overdrawing the account, sending the status message more than once, or creating any other problems? Actually, no.

A cursory read of the documentation on database isolation levels might lead you to believe that serializable means that transactions act as though they are being run serially, i.e. as if they had been synchronized (using Java terminology). But that would be wrong. Databases are only required to honor commitments about serializability from the perspective of the data they store. So in the example above, the database’s only responsibility is to ensure that the balance doesn’t go negative.

Oracle read the fine print carefully and came up with a creative way to improve performance. It lets both transactions proceed full steam ahead, but only permits the first update statement to succeed. The second update will fail with an error:

ORA-08177: Can't serialize access for this transaction.

Your application has to check for this error and retry the whole transaction until it succeeds. It’s really quite smart. Essentially, Oracle is optimistically running the transactions as quickly as possible, hoping they would have been serializable. If that turns out to be wrong, Oracle tries to forget the whole thing happened by aborting the transaction. The result is higher concurrency and better performance than the more obvious locking based design, and it faithfully preserves the serializability rule.

The only problem is that in our example, the status message will get sent too many times. Oracle doesn’t care about the serializability of your non database-related application code. In the example above, only one of the transactions should succeed because the initial balance is $100. But both of them will send the message. The moral here is that you can’t use the serializable database isolation level to manage concurrency in your application code.

So what can you do? You could serialize the whole application code sequence (i.e. wrap it all in a synchronized block) but that would be needlessly throwing away performance. You could create a thread pool that guarantees that requests for the same ID will get serviced by the same thread, but that would be needlessly complicated. The simplest solution (which will work even if you run multiple instances of your entire application) is to have the database lock the row during the transaction, so that if any other transactions touch that row they will block until the running transaction completes.

Oracle allows you to do this by adding the clause FOR UPDATE to your select command, i.e.

select balance from account where id = 123 for update

That’s nice and simple, allows you to run your transaction in the usual, uncomplicated READ_COMMITTED isolation level, allows concurrent processing of different database rows without any possibility of race conditions, and doesn’t require any synchronization in your application code. Unfortunately it’s not portable. It works with Oracle and Sybase, but the rules for MS SQLServer are different.

Here is a solution, the main element of which came from a posting on the Codeplex web site from someone called XIU for which I’m grateful. I thought I would add some more detail in case anyone else has this problem and wants a more cut and pasty solution.

Say you have a class called Product, each instance of which has an ID and a Description, and a class called Order, each instance of which has a Quantity and a Product ID (to be used like a foreign key to designate the order’s product).

These classes must implement the INotifyPropertyChanged interface. Here are the first few lines of each:

public class Product : INotifyPropertyChanged
{
  public int ID { ... }
  public string Description { ... }
  ...
}
 
public class Order : INotifyPropertyChanged
{
  public int ProductID { ... }
  public int Quantity { ... }
  ...
}

Create a simple ViewModel (i.e. binding context) and set the DataContext of the main window to an instance of this object:

namespace ComboBoxDemo
{
  public class ViewModel
  {
    public ObservableCollection<Order> Orders { get; set; }
    public ObservableCollection<Product> Products { get; set; }
 
    public ViewModel()
    {
      Products = new ObservableCollection<Product>();
      Products.Add(new Product(100, "Widget"));
      Products.Add(new Product(101, "Sprocket"));
      Products.Add(new Product(102, "Gadget"));
 
      Orders = new ObservableCollection<Order>();
      Orders.Add(new Order(102, 15));
      Orders.Add(new Order(102, 32));
      Orders.Add(new Order(100, 42));
    }
  }
}

Create a helper class using XIU’s solution:

namespace ComboBoxDemo
{
  public class DataGridComboBoxColumnWithBindingHack : DataGridComboBoxColumn
  {
    protected override FrameworkElement GenerateEditingElement(DataGridCell cell, object dataItem)
    {
      FrameworkElement element = base.GenerateEditingElement(cell, dataItem);
      CopyItemsSource(element);
      return element;
    }
 
    protected override FrameworkElement GenerateElement(DataGridCell cell, object dataItem)
    {
      FrameworkElement element = base.GenerateElement(cell, dataItem);
      CopyItemsSource(element);
      return element;
    }
 
    private void CopyItemsSource(FrameworkElement element)
    {
      BindingOperations.SetBinding(element, ComboBox.ItemsSourceProperty,
        BindingOperations.GetBinding(this, ComboBox.ItemsSourceProperty));
    }
  }
}

This is a variant of the DataGridComboBoxColumn class which handles binding differently to allow the ItemsSource property to have access to the binding context. Now put it all together with the following XAML:

<Window x:Class="ComboBoxDemo.Window1"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:wpf="http://schemas.microsoft.com/wpf/2008/toolkit"
  xmlns:local="clr-namespace:ComboBoxDemo"
  Title="Window1" Height="300" Width="300">
  <wpf:DataGrid ItemsSource="{Binding Orders}" AutoGenerateColumns="False">
    <wpf:DataGrid.Columns>
      <wpf:DataGridTextColumn Header="Quantity" Binding="{Binding Quantity}" />
      <local:DataGridComboBoxColumnWithBindingHack
        Header="Product"
        SelectedValueBinding="{Binding ProductID}"
        SelectedValuePath="ID"
        DisplayMemberPath="Description"
        ItemsSource="{Binding RelativeSource={RelativeSource Findancestor, AncestorType={x:Type Window}}, Path=DataContext.Products}" />
    </wpf:DataGrid.Columns>
  </wpf:DataGrid>
</Window>

The SelectedValueBinding attribute indicates the Order property containing the foreign key designating the product (i.e. which value should be edited by the combo box). The SelectedValuePath attribute indicates which property within the product object contains the product ID, and the DisplayMemberPath attribute indicates which property should actually be displayed in the grid. Finally the ItemsSource attribute indicates how to get the list of products by navigating to the parent window object and looking up the list of products from the parent window’s binding context.

Here is the complete project source as a downloadable zip file.

I hope this saves someone some time, and that it’s easier to do all of this in future versions of the WPF Toolkit. If anyone has a better solution to this problem, please let me know.

First, method invocations and any other operations performed using reflection are not typesafe:

MethodInfo methodInfo = myObject.GetType().GetMethod("MyMethod");
methodInfo.Invoke(myObject, new object[] {});

There is no way at compile time of protecting against a runtime type error in that code sequence. Second, most programmers won’t be able to resist checking that methodInfo is non-null, to protect against a possible null pointer exception:

MethodInfo methodInfo = myObject.GetType().GetMethod("MyMethod");
if (methodInfo != null)
{
  methodInfo.Invoke(myObject, new object[] {});
}

That’s not a bad instinct. After all, who knows what kind of myObject might be passed to this code? But now we’ve subverted the type system twice. It can’t check that we’re calling the method correctly, and it can’t even check that we’re providing the right kind of object. If we provide the wrong kind of object, this code will simply do nothing, probably causing a mysterious, silent failure.

Let’s see, what other kinds of trouble can we get into? Say we refactor the code and change the name MyMethod to something else. A smart IDE can do this automatically for us – but it will miss the reflection-based calls since they are only visible to the IDE as character strings. What will our code example do in this case? It will fail mysteriously and silently again.

Reflection also undermines program correctness by encouraging the creation of implicit contracts. Normally if you want to create a clear contract between two classes, you create an interface. For example, if you have a strange kind of collection class which calls WriteAuditRecord() on each object that is added, you might define the collection to accept only contents of type Auditable, which would be an interface with a WriteAuditRecord() method. Anyone using the collection would get a compile-time type error if they attempted to compile code which inserts objects that do not support that method. That would lead them to read the documentation in the Auditable interface and learn about the contract between the classes. But you could also create a clever solution using reflection to check whether any inserted items support a WriteAuditRecord method, and if so call that method automatically. That would allow programmers to add items to the collection without changing their implementation to implement the Auditable interface. More flexible, right? Except that if a programmer accidentally misspells the method as WriteAudiRecord, it will not get called; another silent error that would normally have been caught by the typechecker. Or even spookier, programmers might not know about this special audit behavior and be surprised when their WriteAuditRecord() method gets called for no apparent reason.

I’d also like to take a poke at another sacred cow: attributes (or annotations if you’re a Java person). My main beef with these is that to use them, you need to use reflection. See above.

I’m not 100% against the use of reflection and annotations. They can be very useful when creating frameworks that need to work on any kind of object (e.g. for serialization and persistence, or for configuration systems like Spring) but my point is they should be used sparingly and you should take a shower afterward.

<?xml version="1.0" encoding="UTF-8"?>

<xsd:schema targetNamespace="http://com.joemo.schema.trade" xmlns="http://com.joemo.schema.trade"
	xmlns:xsd="http://www.w3.org/2001/XMLSchema">

	<!-- web service input types -->

	<xsd:element name="trade">
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element name="security" type="xsd:string" minOccurs="1" maxOccurs="1" />
				<xsd:element name="quantity" type="xsd:integer" minOccurs="1" maxOccurs="1" />
				<!-- note the use of "unbounded"; comments can occur multiple times -->
				<xsd:element name="comments" type="comment" minOccurs="1" maxOccurs="unbounded" />
			</xsd:sequence>
		</xsd:complexType>
	</xsd:element>

	<xsd:complexType name="comment">
		<xsd:sequence>
			<xsd:element name="message" type="xsd:string" minOccurs="1" maxOccurs="1" />
			<xsd:element name="author" type="xsd:string" minOccurs="1" maxOccurs="1" />
		</xsd:sequence>
	</xsd:complexType>

	<!-- web service output types -->

	<xsd:element name="status">
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element name="id" type="xsd:string" minOccurs="1" maxOccurs="1" />
				<xsd:element name="message" type="xsd:string" minOccurs="1" maxOccurs="1" />
			</xsd:sequence>
		</xsd:complexType>
	</xsd:element>

</xsd:schema>

Next, we need the trade.wsdl file which imports the schema file and completes the WSDL definition:

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions targetNamespace="http://com.joemo.schema.tradeservice"
	xmlns="http://com.joemo.schema.tradeservice"
	xmlns:tr="http://com.joemo.schema.trade"
	xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
	xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

	<wsdl:types>
		<xsd:schema targetNamespace="http://com.joemo.schema.tradeservice">
			<xsd:import namespace="http://com.joemo.schema.trade" schemaLocation="trade.xsd" />
		</xsd:schema>
	</wsdl:types>

	<wsdl:message name="tradeInput">
		<wsdl:part name="trade" element="tr:trade" />
	</wsdl:message>

	<wsdl:message name="tradeOutput">
		<wsdl:part name="status" element="tr:status" />
	</wsdl:message>

	<wsdl:portType name="TradeService">
		<wsdl:operation name="book">
			<wsdl:input message="tradeInput" />
			<wsdl:output message="tradeOutput" />
		</wsdl:operation>
	</wsdl:portType>

	<wsdl:binding name="TradeServiceHTTPBinding" type="TradeService">
		<wsdlsoap:binding style="document"
			transport="http://schemas.xmlsoap.org/soap/http" />
		<wsdl:operation name="book">
			<wsdlsoap:operation soapAction="" />
			<wsdl:input>
				<wsdlsoap:body use="literal" />
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:body use="literal" />
			</wsdl:output>
		</wsdl:operation>
	</wsdl:binding>

	<wsdl:service name="TradeServicePorts">
		<wsdl:port binding="TradeServiceHTTPBinding" name="TradeService">
			<wsdlsoap:address
				location="http://localhost:9084/tradeService/TradeServicePorts" />
		</wsdl:port>
	</wsdl:service>

</wsdl:definitions>

Now we need a Maven project file that will take this WSDL and generate the Java code. Here’s what the pom.xml file looks like. It’s long and messy but it does a lot. It specifies all the dependencies and the compiler level, includes the rule to generate Java code from WSDL whenever necessary, and includes Jetty and WTP support for testing and running the web services in different environments.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.joemo</groupId>
	<artifactId>ws-example</artifactId>
	<packaging>war</packaging>
	<version>0.1</version>
	<name>ws-example</name>
	<url>http://maven.apache.org</url>
	<properties>
		<cxf.version>2.1</cxf.version>
		<spring.version>2.5</spring.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-core</artifactId>
			<version>${cxf.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-frontend-jaxws</artifactId>
			<version>${cxf.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-transports-http</artifactId>
			<version>${cxf.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-common-utilities</artifactId>
			<version>${cxf.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.4</version>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<!-- Use Java 5 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.5</source>
					<target>1.5</target>
				</configuration>
			</plugin>

			<!-- CXF WSDL-to-Java code generation -->
			<plugin>
				<groupId>org.apache.cxf</groupId>
				<artifactId>cxf-codegen-plugin</artifactId>
				<version>2.0.6</version>
				<executions>
					<execution>
						<id>generate-sources</id>
						<phase>generate-sources</phase>
						<configuration>
							<sourceRoot>${basedir}/target/generated/src/main/java</sourceRoot>
							<wsdlOptions>
								<wsdlOption>
									<wsdl>src/main/resources/trade.wsdl</wsdl>
								</wsdlOption>
							</wsdlOptions>
						</configuration>
						<goals>
							<goal>wsdl2java</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<!-- Jetty support for testing -->
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>maven-jetty-plugin</artifactId>
			</plugin>
		</plugins>
		<!-- Eclipse WTP support -->
		<pluginManagement>
			<plugins>
				<plugin>
					<artifactId>maven-eclipse-plugin</artifactId>
					<configuration>
						<wtpversion>2.0</wtpversion>
						<wtpapplicationxml>true</wtpapplicationxml>
						<wtpmanifest>true</wtpmanifest>
						<downloadSources>true</downloadSources>
						<downloadJavadocs>true</downloadJavadocs>
						<projectNameTemplate>[artifactId]-[version]</projectNameTemplate>
						<manifest>${basedir}/src/main/resources/META-INF/MANIFEST.MF</manifest>
					</configuration>
				</plugin>
			</plugins>
		</pluginManagement>
	</build>
</project>

Among other things, the rules in this pom.xml file will generate a Java interface called TradeService (based on the names in the WSDL file). The only code we will have to write is the implementation of this interface. Although this generation is done automatically by any Maven commands that need it (e.g. mvn package or mvn install) you might want to force it to be done sooner rather than later, so that you can refresh your Eclipse project with the generated code, enabling Eclipse to recognize the interface that you’re trying to implement. You can do this using the commands:

mvn generate-sources
mvn eclipse:clean eclipse:eclipse

This generates Java code from the WSDL, then regenerates the Eclipse project files, after which you should be able to refresh the project in Eclipse. If you see errors about libraries not being found, you may need to configure Eclipse to know about your Maven repository, i.e. select Eclipse / Window / Preferences / Java / Build Path / Classpath Variables, then enter the appropriate settings, e.g.

Name: M2_REPO
Path: C:/Documents and Settings/MyAccount/.m2/repository

Once the project is properly configured in Eclipse, you can fill in the implementation:

package com.joemo.service;

import trade.schema.joemo.com.Comment;
import trade.schema.joemo.com.Status;
import trade.schema.joemo.com.Trade;
import tradeservice.schema.joemo.com.TradeService;

public class TradeServiceImpl implements TradeService {

	public Status book(Trade trade) {
		System.out.print ("Booking security ");
		System.out.print (trade.getSecurity());
		System.out.print (", quantity ");
		System.out.print (trade.getQuantity());
		System.out.println();
		if (trade.getComments() != null) {
			System.out.println ("Comments:");
			for (Comment c : trade.getComments()) {
				System.out.print (c.getAuthor());
				System.out.print (": ");
				System.out.print (c.getMessage());
				System.out.println();
			}
		}
		Status s = new Status();
		s.setId("12345");
		s.setMessage("ok");
		return s;
	}

}

We are almost done. We still need a web.xml file which will direct SOAP requests to the CXF infrastructure:

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:appContext.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<servlet>
		<servlet-name>dispatcher</servlet-name>
		<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcher</servlet-name>
		<url-pattern>/*</url-pattern>
	</servlet-mapping>
</web-app>

Finally, we need the appContext.xml file, which is the Spring configuration file loaded by CXF that defines the web service endpoint:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:jaxws="http://cxf.apache.org/jaxws"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd"
	default-dependency-check="none" default-lazy-init="false">

	<!-- Load the needed resources that are present in the cxf* jars -->
	<import resource="classpath:META-INF/cxf/cxf.xml" />
	<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
	<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

	<!-- Hook up the web service -->
	<jaxws:endpoint id="ws-example" implementor="com.joemo.service.TradeServiceImpl"
		address="/ws-example" />

</beans>

That’s everything. There are six files, only one of which contains any Java code. You need to make sure you put each file in the right place:

ws-example/pom.xml
ws-example/src/main/resources/trade.xsd
ws-example/src/main/resources/trade.wsdl
ws-example/src/main/resources/appContext.xml
ws-example/src/main/webapp/WEB-INF/web.xml
ws-example/src/main/java/com/joemo/service/TradeServiceImpl.java

A zip file of this example is available for download here. To build and run it, you will need Maven to be installed on your development system. Unzip the file, and in the directory containing the pom.xml file, run the command:

mvn jetty:run

That will generate the Java code from the WSDL, build the example, and run the web service in the Jetty container. You should be able to visit the URL http://localhost:8080/ws-example/ws-example?wsdl from a web browser and see the WSDL for the web service, test the web service using SoapUI, and so on.

Alternatively you can run the command:

mvn eclipse:eclipse

and follow the directions from my earlier blog entry to run the example using Eclipse WTP, which will allow you to edit the code while keeping it synchronized with a live application server.

Good luck! If you encounter any problems using this template, please email me or post a comment so that I can look into it and revise the instructions if necessary.

Second, keep in mind that there are three important APIs which are inter-related: JAX-WS, JAXB, and StAX. Once you understand how these fit together, everything else falls into place more easily.

JAX-WS

Let’s begin our journey with the latest Sun standard for creating and consuming web services: JAX-WS, which stands for Java API for XML Web Services. This standard was introduced in 2004. You can ignore JAX-RPC, since JAX-WS replaces it.

There are three noteworthy implementations of JAX-WS. The first is from Sun, and is called JAX-WS RI for the JAX-WS Reference Implementation (they always had a way with names). The second and third are both from the Apache Group and are called Axis2 and CXF. You can ignore Axis1, XFire, and Celtix, since they are all obsolete. There is also a web service framework called Spring-WS, but it’s not JAX-WS compliant.

So if you are creating web services in Java, the first order of business is to to choose an implementation to work with, and unless you have a reason not to, you should probably stick to one that complies with JAX-WS, which means either JAX-WS RI, Axis2, or CXF.

Related to these is an open source project from Sun called Web Services Interoperability Technologies (WSIT), previously known as Project Tango. This is an implementation of several web service standards (WS-SecurityPolicy, WS-ReliableMessaging, and so on). Metro is an open source web service stack which is a combination of JAX-WS RI and WSIT (so it’s actually a reasonable fourth option).

JAX-WS is oriented around SOAP web services, but many programmers are now using the REST approach. Sun is coming out with the JAX-RS API to support that, but it’s not quite ready yet.

JAXB

Web service development requires mapping between XML and Java objects. JAXB is the Sun API for that (also referred to as JAXB2 since the latest version is the important one). There are two noteworthy implementations: JAXB-RI (Sun’s reference implementation) and JaxMe (the unfortunately named contribution from Apache). JaxMe is in the incubation stage and is not formally part of Apache yet. There are many other interesting and popular XML/Java mapping frameworks, but most of them are not compliant with JAXB. Examples include Castor (from Codehaus), JiBX (a spectacularly fast open source implementation), and XMLBeans (a flexible implementation from Apache).

A recurring source of confusion is that in the past, Sun was less clear about the distinction between APIs and reference implementations, so people would take JAXB to mean both, and you would often see online articles like “Which is better: JAXB or JiBX?” But today developers should always try to use the JAXB API, which will enable a choice of compliant implementations such as JAXB-RI or JaxMe with minimal or no code changes.

StAX

For Java code that needs to read and write large XML documents quickly without necessarily mapping them to objects, there is the Streaming API for XML (StAX). There are several implementations of this API too. There is the Sun Java Streaming XML Parser called SJSXP (another snappy name from Sun), the Woodstox open source implementation which is excellent, and the StAX reference implementation from Codehaus which is referred to simply as StAX (unfortunately perpetuating the confusion between APIs and implementations). Xerces is a streaming XML processing library which used to be part of the Apache project, and work was underway to make it StAX compliant, but that was dropped.

Putting it all together

Web services need to process XML, sometimes mapping it to and from Java objects (e.g. for creating proxy objects and an RPC-like experience), and sometimes processing it directly (e.g. for streaming results when high performance is needed). Therefore Sun designed the JAX-WS API to rely on the JAXB API, which makes perfect sense; any JAX-WS compliant web service implementation should therefore be able to use any JAXB compliant mapping library. Other relationships between these APIs are up to individual implementations. For example, JAX-WS RI supports the StAX API, so you can use any StAX implementation for streaming. CXF also supports the StAX API, as well as a host of Java/XML mapping options including JAXB (allowing the use of any JAXB compliant implementation), XMLBeans, Castor, and JiBX. Yes, they are heroes.

So if you get confused, just ask yourself clarifying questions like: Does this Java web service library support JAX-WS? Which JAXB compliant Java/XML mapping implentation shall I use? Which is better for processing streaming XML? Woodstox or the StAX reference implementation?

If you’re still confused, then just accept the recommendations I promised not to make: Use CXF for your web services (which complies with JAX-WS), JAXB-RI for your Java/XML mapping (which complies with JAXB), and Woodstox for streaming (which complies with StAX).

Error instantiating builder 'org.eclipse.stp.sc.annvalidator'.
Plug-in org.eclipse.stp.sc.annvalidator was unable to load class org.eclipse.stp.sc.annvalidator.builder.AnnValidator.

What? Did they even test this? And who is Ann Validator anyway? A quick Google search turned up incomprehensible articles with titles like “AnnValidator missing from Ganymede Update”. The gist of the articles was basically “oh yeah, we should clean up our releases better”.

I’m probably oversimplifying the Eclipse point of view, but I don’t really care. The point is, now I have to research an obscure problem in order to perform something that should be the most basic of activities – creating a simple web service, using a fresh download of a supposedly mature IDE.

There is only one thing keeping me from switching to Netbeans immediately and recommending that everyone dump Eclipse: I’m still waiting for a good Perforce plugin. Okay, two things: I’m also addicted to Max Uermann’s Goto File plugin.

It installed like a dream on top of DD-WRT, and the user interface is simple and clean. Most of the complexity is devoted to QoS functions, which I actually care about (unlike many of the obscure routing options provided by the original Linksys firmware) since I use my home computers for streaming music, Skype, and other network-intensive applications. Furthermore it provides nice usage monitoring and visualization tools. The user interface is a nice red color, the exact same shade as Campbell’s tomato soup.

After installation, my home network seems noticeably faster, but that may just be cognitive dissonance. (After all, if I spent an entire evening not making my network faster, that would make a pretty poor blog entry.) The main question now is whether my router’s reliability will improve, but from reviews online and my initial experience, I’m optimistic. We’ll see over the next few months.

If you decide to try installing Tomato, make sure your router hardware version is supported. For example, Tomato isn’t supported on the Linksys WRT54G V5 or later since Linksys removed half the RAM in all versions after V4.

Then consider the manner by which all those people collaborated. Nobody was coerced, and it wasn’t necessary to gather everyone into a giant room to plan it all. Rather, it all came about gradually over the course of decades, fueled by a combination of personal initiative, market forces, and government action. It’s one of the greatest triumphs of managed capitalism. (We are all Keynesians now.) In Europe aircraft are made by English, French, and German people working together. Could anyone imagine that fifty years ago? Economic integration is the primary force protecting us from another world war.

But what’s most amazing is that flying is routine. At the tip of that orange line in the sky was a silver tube filled with people having dinner, reading newspapers, and generally acting as though it’s not a big deal to shoot through the sky at 600 miles per hour. But it is.

But if you’re building web applications with Maven, it’s not so easy. Maven is a fantastic tool for building applications and managing dependencies, but it lends itself to a more batch-oriented mode of operation in which you build and deploy war files from the command line. I found myself wishing I could have the best of both worlds; building my web applications using Maven, but with a seamless edit/compile/test cycle when using Eclipse. Then I discovered the WTP (Web Tools Platform) project. Hallelujah!
(more…)

He’s right, isn’t he? Having the same company offer both virtualization and grid solutions is a truly virtuous pairing. First you tell people they need a grid solution to make a huge pool of computers look like a single one, then after it’s all set up you sell them virtualization software. It’s beautiful. It’s like if, for example, Nestle and Jenny Craig got together to simultaneously offer chocolate products and dieting solutions. Oh wait, they did: Nestle to buy Jenny Craig.
(more…)

Increasingly, software is being designed based on the idea of treating network resources as local. The practice of generating proxy objects to invoke remote services increases the tendency to think this way, as does the success of HTTP based remote invocation patterns like REST, SOAP, etc. (It’s tempting to think of HTTP services like function calls: Send request with parameters, wait until results come back, proceed.)

But this is a bad idea. The concept of a network as a means of instantaneous communication between software components anywhere on the globe is an incorrect abstraction. Software should be designed based on the notion that networks are unreliable and introduce unpredictable amounts of latency into communication.

(more…)

It’s helpful to keep a checklist of these and review them at the beginning of any new project, especially if the project is in an unfamiliar IT environment. Here’s my checklist of ten.

(more…)

http://nutrun.com/weblog/no-more-jars/

So here’s my technical point. First let me clarify that by declarative programming, I mean the general practice of writing “I want this”, rather than “do this, then do that, then do the other thing”. Wikipedia defines it nicely:

http://en.wikipedia.org/wiki/Declarative_programming

Declarative programming is generally a good thing because it enables cleaner, more powerful abstractions. You are saying what you want, and leaving it up to a framework to decide how to carry out your wishes. That’s what’s great about Spring; your configuration file explains how to make each kind of thing, and the Spring framework decides when to instantiate classes and how to wire them up.

The problem is that taken to an extreme, you end up with a big pile of configuration files and no code. That’s great if everything works perfectly, but if your program does not work as expected, you are in trouble. Declarative programs are much harder to analyze and understand than imperative ones. Debuggers are not especially useful – you end up stepping through the implementations of the frameworks (when the whole point of the exercise was to build on abstractions whose implementations you don’t need to understand). And the frameworks are typically much more general than necessary for your application (since they were designed to serve everybody, not just you) so you have a lot more code to wade through than you would have had.

Declarative frameworks can also defeat clever features in IDEs. When browsing a Spring-based application for example, hitting F3 to find the definition of something is much less helpful than it used to be. Typically you end up jumping to an interface, and the only way to figure out the exact class that was instantiated is to parse and understand the Spring configuration (if you even know for sure which one was used in the running program).

An important rule in programming style used to be to minimize the scope of variables, so that you can understand as much as possible when looking at a small code fragment. (K&R brace style was even designed to support this – you can see more logic in fewer lines of code.) Declarative programming defeats this.

There’s no simple answer. I think what’s going to happen is that IDEs like Eclipse are going to learn about the most popular declarative programming frameworks such as Spring. For example when you hit F3 in Eclipse it should look at the Spring configuration files to decide what classes to display. And I also think that the pendulum will swing back a bit, and imperative programming will start finding favor again.

I wrote this article a couple of years ago and was recently asked to republish it; I thought I would do it here.

About closures

Closures are functions which remember their lexical environment, i.e. have some state of their own. You can think of a closure as a little package of two items: a pointer to a function and a pointer to a set of name/variable bindings. Closures can typically be treated like any other programming language objects, e.g. they can be stored in variables, passed to functions, and so on.

The best way to understand closures is to think about some examples in Scheme. Here is an extremely brief introduction to Scheme syntax:

(lambda (x)
  (+ x 1))

That is how you would write an anonymous (i.e. unnamed) function which adds one to its input. You can read this code as “a function of one argument x, which returns the sum x plus one”.

In Scheme you could assign this function to a variable as follows:

(define f (lambda (x)
              (+ x 1)))

Then you could use f like a built-in function:

(f 8)
-> 9

Now consider this more complicated example:

(define f (lambda (x)
            (lambda (y)
              (+ x y))))

This is the simplest non-trivial example using closures. Think about what f does. It’s a function of one argument (x). When you call it, you pass it a single number as an argument, which gets bound to x. The return value from calling the function is another function which takes one argument (lambda (y) ...) This new function always adds x to its input (whichever x was passed when the function was created). Let’s try a couple of examples:

(define adder-8 (f 8))
(define adder-9 (f 9))

This defines adder-8 and adder-9 as functions that add 8 or 9 to their input, respectively. The two functions adder-8 and adder-9 are closures, because they have state. Almost like magic, they remember the values for “x” at the time of their creation, since the variable “x” was in the lexical environment of the code that created them. The two closures never get confused about which is the correct value for “x”; they both have their own copies. A scheme interpreter might represent them something like this:

(adder-8 10)
-> 18

(adder-9 10)
-> 19

If you try to reproduce this behaviour in a language that does not support closures (such as C), you’ll find it’s quite messy.

Closures can do many of the same things as objects. Both are ways of combining code with local state. Here is another example:

(define make-counter (lambda ()
                       (let ((c 0))
                         (lambda ()
                           (set! c (+ c 1))
                           c))))

;;; example usage

(define counter1 (make-counter))
(define counter2 (make-counter))

(counter1)
-> 1

(counter1)
-> 2

(counter1)
-> 3

(counter2)
-> 1

(counter2)
-> 2

(counter1)
-> 4

Each call to make-counter manufactures a counter, represented as a closure. Every time you invoke the closure you get the next value. You can manufacture as many counters as you like, each keeping independent track of its current value. The counter values can only be accessed by their parent closures, so this example shows data hiding as well.

(By the way, there is another use of the term “closure” in computer science, unrelated to the above. That’s the “Kleene closure”, referring to the “*” operator used in regular expressions, Extended Backus-Naur Form, and similar formalisms to specify a match for zero or more occurrences of the preceding expression. For example, the regular expression “be*t” would match the string “bt”, “bet”, “beet”, “beeeeet”, and so on.)

About classes (really about objects)

Unfortunately it’s hard to say exactly what an object is, since the various object-oriented languages, object-oriented databases, and distributed object systems all implement them differently. Over the years I’ve settled on this definition:

An object is any association of a data structure with one or more functions that operate on that data structure.

An object oriented language is any language that has these three attributes:

1. Supports the creation of objects (as defined above), and the invocation of their associated functions.
2. Supports some notion of polymorphic variable that can store more than one type of object.
3. Has a mechanism for selecting functions at runtime based on the current (runtime) type of a polymorphic variable.

So for example, C++ qualifies as an object-oriented language because you can write this:

    #include 
    using namespace std;

    class person
    {
    public:
       virtual char* name () { return "Generic Person"; }
    };

    class teacher : public person
    {
    public:
       virtual char* name () { return "Richard Feynmann"; }
    };

    class doctor : public person
    {
    public:
       virtual char* name () { return "Norman Bethune"; }
    };

    main ()
    {
       person *p = chooseRandomPersonType ();
       cout << p->name () << endl;
    }

C++ achieves attribute 1 through the use of classes with associated member functions. Attribute 2 is achieved through the use of inheritance. In this example, variable "p" can hold pointers to a generic person, teacher, or doctor. Attribute 3 is achieved through the use of virtual functions. In this example, the code that calls function "name" can end up executing one of three different bits of code. That code is selected at runtime based on the type of whatever "p" is pointing to.

There are many other features which are nice to have (data hiding, garbage collection, multiple inheritance, separation of interface from implementation, etc.) but in my view those are not essential to object orientation. Inheritance is not even essential, since there are alternative ways of achieving attribute 2.

Objects and closures are equivalent in the sense that they are both ways of unifying code and state. So which should you use? Fortunately it's rarely necessary to choose. Most programming languages are biased toward one or the other as their standard way of building abstractions. For example C++ has support for objects, but not for closures. Scheme has support for closures but not for objects. So just use the "when in Rome" principle.

About callbacks

Sometimes it's necessary to call a function which goes into an infinite loop, waits for various events and handles them as they occur. Many user interface libraries are organized this way, for example.

In these cases you often want to customize the handling of certain events, while retaining the default behavior for others. Libraries can support this by allowing you to register a handler function for each customized event. When a customized event occurs, the system will call the handler function instead of doing the standard processing. Here is a pseudocode example:

    void handleButtonPress (...)
    {
        ... customized button press handling ...
    }

    main
    {
       ...
       uiCreateButton (x, y, w, h, NULL);                // Default handler
       uiCreateButton (x, y, w, h, &handleButtonPress);  // Customized handler
       ...
       uiStartEventLoop ();
    }

The "handleButtonPress" function is referred to as a "callback", since you're asking the toolkit library to "call you back" whenever that button is pressed.

Callbacks mesh very nicely with objects and closures. For example a library can be designed to accept a closure or an object as a callback, rather than a pointer to a function. If the callback is an object, the toolkit can invoke some agreed-upon method whenever the event of interest occurs.

About continuations

Continuations are an extremely strange notion, popularized in the Scheme programming language but also available in other languages such as Ruby. A continuation is a snapshot of a program's execution state, packaged into an object that can be stored in data structures, passed to functions, etc. A continuation can be invoked like a function, which immediately causes the current execution state to be replaced with the state stored in the contination.

The simplest use of continuations is for exception handling. Here's a Scheme example:

    (call/cc
      (lambda (k)
        (... do some computation ...)
        (if problem occurs, call (k))
        (... do more computation ...)))

The Scheme command "call/cc" (an abbreviation for "call-with-current-continuation") creates a continuation, then invokes the given function (lambda (k) ...), passing it the continuation as an argument.

So the code (lambda (k) ...) starts executing immediately, with the continuation object stored in the variable "k". If "k" is invoked as a function, the computation in progress is aborted and the entire call/cc clause returns immediately.

Because continuations can be stored in data structures, you can use them to implement interesting control abstractions like cooperative multitasking. Continuations are a little bit like process control blocks in an operating system. They are also like the setjmp/longjmp facility in C/C++, except that they remember the entire execution state of the program at the time of their creation, and can resume it later, even if the stack frames have disappeared. That's the part that seems like magic. Consider this example in the C language, using setjmp/longjmp:

    #include 
    #include 
    #include 

    jmp_buf env;

    void mysterious ()
    {
      int x = 3;
      int y = 4;

      if (setjmp (env) != 0)
        {
          printf ("longjmp landed in the middle of the mysterious function!\\n");
          printf ("x is %d, y is %d - corrupted?\\n", x, y);
          exit (1);
        }
    }

    main ()
    {
      mysterious ();
      longjmp (env, 1);
    }

In this example, the mysterious function does a "setjmp", then returns normally. What happens if you try to "longjmp" there later? In C with setjmp/longjmp, that's illegal. You're jumping to a dead stack frame. If you try running this code, you'll probably find that x and y get corrupted after the longjmp.

Here's the exact same code translated into Scheme, using continuations:

    (define env #f)

    (define mysterious
      (lambda ()
        (let ((x 3)
              (y 4))
          (if (not (= 0 (call-with-current-continuation
                         (lambda (k)
                           (set! env k)
                           0))))
              (begin
                (display "longjmp landed in the middle of mysterious function!")
                (newline)
                (display "x is ")
                (display x)
                (display ", y is ")
                (display y)
                (newline)
                (exit))))))

    (mysterious)
    (env 1)

In the Scheme version, the values 3 and 4 are always printed correctly. After the continuation has been saved in the variable "env", it can be called at any time while the program is executing, even after the mysterious function has returned. Whenever the continuation is invoked, you'll be popped right into the middle of the "mysterious" function, executing normally, with all the variables in place.

Setjmp/longjmp do their job by fiddling with the stack pointer, but they don't actually save the stack. Once a subroutine has returned, its local variables are gone. But a continuation actually saves the entire stack, and restores it if necessary.

This is simple if the data of interest is a DataSet object or other collection designed for easy integration with grids. But it’s not so easy if you want to connect the grid to a collection of application-specific objects. Most grids are designed such that if you assign the DataSource property to an arbitrary list of objects, something reasonable happens. The grid will typically use reflection to get the names and datatypes of the object’s members. But if you want to control which columns are displayed, how the values are formatted, and so on, then this solution is inadequate. And if the objects contain lists of other objects and you want the grid to be able to display the sublists, the problem is even more difficult.

Microsoft’s ITypedList interface provides a solution. It’s even rather elegant and minimal, although you wouldn’t think so from reading the documentation and examples. Underlying this solution is the PropertyDescriptor class, which provides all of the information required to deal with a particular table column, i.e. its datatype, display name, how to get its value given a row-level object, and so on. Specifically this class’s PropertyType property returns the column’s datatype as a Type object, it’s DisplayName property returns the column’s display name as a string, it’s GetValue method takes a row-level object and returns the column’s value, and so on. This is a great building block. All we need to do is provide the grid with a suitable list of property descriptors whenever the grid needs to know how to display a row. That’s where the ITypedList interface comes in. It provides a method called GetItemProperties which returns a list of PropertyDescriptor objects providing the grid with the information it needs. Thus the basic structure of our solution is this:

class MyCustomList : ArrayList, ITypedList
{
  PropertyDescriptorCollection ITypedList.GetItemProperties (PropertyDescriptor[] listAccessors)
  {
    ... return list of PropertyDescriptor objects ...
  }

  string ITypedList.GetListName(PropertyDescriptor[] listAccessors)
  {
    return "whatever";  // not important - ignore this for now
  }
}

The next question is: How do we make PropertyDescriptor objects that do what we need? There are two strategies for creating them. There’s the clever way (which is to use .NET’s reflection capabilities to give you a list of PropertyDescriptor objects for a particular class, remove the ones you don’t want, then customize the rest) and there’s the non-clever way (which is to create them from scratch). For this example, we will go with the non-clever way, which is better for tutorial purposes. Not only that, we will do the dumbest, simplest thing possible: Create a subclass called TutorialExamplePropertyDescriptor with no additional properties. The idea is to allocate one of these whenever we need a property descriptor, storing only the name in the base part of the object. The various methods (PropertyType, DisplayName, etc.) will be overridden with versions that switch on the name to dispatch to the right code. Here is the idea:

class TutorialExamplePropertyDescriptor : PropertyDescriptor
{
  public TutorialExamplePropertyDescriptor(string descriptorName)
    : base(descriptorName, new Attribute[0])
  {
    // constructor does nothing except store the name in the base class
  }

  public override Type PropertyType
  {
    get
    {
      // switch on the name to return the appropriate type
      switch (this.Name)
      {
        case "CustName":           return typeof(string);
        case "CustOrders":         return typeof(ArrayList);
        // etc...
      }
    }
  }

  // ... override other methods - DisplayName, GetValue, etc.
}

To return a list of property descriptors we just write:

return new PropertyDescriptorCollection (new PropertyDescriptor[]
{
  new TutorialExamplePropertyDescriptor("CustName"),
  new TutorialExamplePropertyDescriptor("CustOrders")
});

This is a poor design, inefficient and wasteful of memory, but is (hopefully) simple and readable and will help clarify the purpose of property descriptors. After you understand this example, you can improve the implementation by caching the lists of PropertyDescriptor objects, avoiding the runtime switch statements, using reflection, and so on. Note that if your custom collection is not actually a list of class instances, but something else – such as a giant 2D array, a list of Hashtables, or some other data structure – then you can’t use reflection anyway, since there is no class to reflect over. In that case you’ll be glad this example is the non-clever kind.

We now have all of the building blocks we need to handle simple bindable lists (i.e. without sublists). We simply implement the ITypedList.GetItemProperties method and have it return a suitable list of TutorialExamplePropertyDescriptor objects. Then we can bind a grid to our list and the rows should display exactly as we want.

But let’s not stop here. What if we want to have rows which contain sublists? For example what if we are binding a list of Customer objects which each have a sublist of Order objects? How does the grid know how to display the Order rows? And if the Order objects contain sublists of OrderItem objects, how does the grid know how to display those? The first point is that the grid needs to know which columns represent list values. That’s easily done – it checks the property descriptors and if any of them are list types (e.g. ArrayList) it displays a “plus” next to the row indicating that the row can be expanded to show the sublist. The second point is that the grid needs a separate list of property descriptors for each type of row it can display. It obtains these lists by calling the ITypedList.GetItemProperties method every time it needs a list of property descriptors for a particular type of row, passing an argument called listAccessors to specify which type of row it wants to know about. When the grid wants to know about the top-level (primary) rows, it passes a null argument. But then say the user navigates to the Orders sublist for a particular customer; then the grid calls the GetItemProperties method passing it the Orders property descriptor, meaning that it is looking for the PropertyDescriptor list for the Order row type. If the user then navigates to the OrderItems field within the order, then the grid calls the GetItemProperties method passing it an array with the Orders property descriptor as the first element, and the OrderItems property descriptor as the second element. The listAccessors array thus represents the array of PropertyDescriptors that the user has navigated to so far.

This listAccessors argument to the GetItemProperties method is a source of much confusion, but the basic idea is simple: It’s the grid’s way of asking “given where I’ve navigated so far, how do I display the next kind of row?” Generally the implementor of this method needs to look at only the last entry in that array to figure out the answer, e.g. if the user has navigated to the OrderItems property, then you don’t care how the user navigated there – you know which property descriptors to return as the result. But (to come up with an artificial example) you could imagine a Customer class containing the properties CurrentOrders and ShippedOrders, both containing lists of OrderItem objects – and it’s conceivable that you might want to display the OrderItem objects differently for each of the two order lists. In that case, whenever the last listAccessors entry is of type OrderItem, you would check the second-last entry as well, and return different property descriptors depending on whether it was for CurrentOrders or ShippedOrders.

All this complexity applies only to lists that contain sublists. If you want to bind a simple list without sublists, then the listAccessors property is simple to implement – you always return the same list of property descriptors (for the top-level rows) without even looking at the listAccessors argument. Or if you want to be tidy, you can throw an exception if listAccessors is non-null (since it shouldn’t be in this case).

Here’s the simplest possible code example I could think of to illustrate all of these concepts together. I’ve removed linefeeds, made properties public without writing getters and setters, and taken other measures for brevity. (Or you can download the working C# code example and build it in Visual Studio.)

namespace DataBindingTutorialExample
{
  class Customer
  {
    public string CustName;
    public ArrayList CustOrders;
  }

  class Order
  {
    public DateTime OrderDate;
    public ArrayList OrderItems;
  }

  class OrderItem
  {
    public int ItemQuantity;
    public string ItemDescription;
  }

  class CustomerList : ArrayList, ITypedList
  {
    PropertyDescriptorCollection ITypedList.GetItemProperties(PropertyDescriptor[] listAccessors)
    {
      if (listAccessors == null)
      {
        return new PropertyDescriptorCollection (new PropertyDescriptor[]
            {
              new TutorialExamplePropertyDescriptor("CustName"),
              new TutorialExamplePropertyDescriptor("CustOrders")
            });
      }
      else
      {
        string parentDescriptorName = listAccessors[listAccessors.Length - 1].Name;
        switch (parentDescriptorName)
        {
          case "CustOrders":
            return new PropertyDescriptorCollection(new PropertyDescriptor[]
                {
                  new TutorialExamplePropertyDescriptor("OrderDate"),
                  new TutorialExamplePropertyDescriptor("OrderItems")
                });

          case "OrderItems":
            return new PropertyDescriptorCollection(new PropertyDescriptor[]
                {
                  new TutorialExamplePropertyDescriptor("ItemQuantity"),
                  new TutorialExamplePropertyDescriptor("ItemDescription")
                });

          default:
            throw new Exception("Not implemented: " + parentDescriptorName);
        }
      }
    }

    string ITypedList.GetListName(PropertyDescriptor[] listAccessors)
    {
      return "whatever";
    }
  }

  class TutorialExamplePropertyDescriptor : PropertyDescriptor
  {
    public TutorialExamplePropertyDescriptor(string descriptorName)
      : base(descriptorName, new Attribute[0])
    {
    }

    public override Type ComponentType
    {
      get
      {
        switch (this.Name)
        {
          case "CustName":         return typeof(Customer);
          case "CustOrders":       return typeof(Customer);
          case "OrderDate":        return typeof(Order);
          case "OrderItems":       return typeof(Order);
          case "ItemQuantity":     return typeof(OrderItem);
          case "ItemDescription":  return typeof(OrderItem);
          default:                 return null;
        }
      }
    }

    public override Type PropertyType
    {
      get
      {
        switch (this.Name)
        {
          case "CustName":           return typeof(string);
          case "CustOrders":         return typeof(ArrayList);
          case "OrderDate":          return typeof(DateTime);
          case "OrderItems":         return typeof(ArrayList);
          case "ItemQuantity":       return typeof(int);
          case "ItemDescription":    return typeof(string);
          default:                   return null;
        }
      }
    }

    public override object GetValue(object component)
    {
      switch (this.Name)
      {
        case "CustName":         return ((Customer)component).CustName;
        case "CustOrders":       return ((Customer)component).CustOrders;
        case "OrderDate":        return ((Order)component).OrderDate;
        case "OrderItems":       return ((Order)component).OrderItems;
        case "ItemQuantity":     return ((OrderItem)component).ItemQuantity;
        case "ItemDescription":  return ((OrderItem)component).ItemDescription;
        default:                 return null;
      }
    }

    public override string DisplayName
    {
      get
      {
        switch (this.Name)
        {
          case "CustName":         return "Customer name";
          case "CustOrders":       return "Customer orders";
          case "OrderDate":        return "Order date";
          case "OrderItems":       return "Order items";
          case "ItemQuantity":     return "Quantity";
          case "ItemDescription":  return "Description";
          default:                 return null;
        }
      }
    }

    public override bool IsReadOnly { get { return true; } }
    public override void SetValue(object component, object value)  { throw new Exception("Not implemented."); }
    public override void ResetValue(object component)              { throw new Exception("Not implemented."); }
    public override bool CanResetValue(object component)           { throw new Exception("Not implemented."); }
    public override bool ShouldSerializeValue(object component)    { throw new Exception("Not implemented."); }
  }
}

Notes:

This code has been tested with the .NET 1.1 DataGrid and the Infragistics Ultragrid. It works as a data source for either, but looks much nicer with the Ultragrid.

If you change the property descriptor’s IsReadOnly property to return false and fill in the code for the SetValue method, the grid will allow simple edits. But for more complex editing capabilities (e.g. adding/deleting rows, sorting by field, etc.) your collection needs to implement the IBindingList interface.

In some cases when using the Microsoft DataGrid, setting the AllowNavigation property to true causes it to display useful navigation buttons on the right hand side of the title bar. This seems to work in .NET 2.0 but not .NET 1.1.

Note: This example does not work with the .NET 2.0 DataGridView class, which does not support hierarchical list display.

You can download a working C# code example here.

So rule #1 is: If a piece of code is in the public domain, you can incorporate it into your commercial application, email it to all your friends, or wallpaper your apartment with it. There are no restrictions whatsoever.

If a piece of code is not in the public domain, the copyright holder owns the code and can dictate the terms of its use. He may require that you pay license fees, use the software only in non-commercial applications, or use the software only on the second Tuesday of each month. The copyright holder can require anything at all, limited only by his imagination. If you don’t like the terms, you are free not to use the software.

Most open source software is copyrighted under terms that allow you to use the software freely (e.g. incorporate it into your application, resell it, etc.) However there are sometimes strings attached – for example you may have to display a banner mentioning the open source software, or include its copyright notice along with your own.

So rule #2 is: If you include non-public-domain components in your application (whether open source or not), you must review their licensing terms and make sure that you comply with all of them. You can’t assume that open source software is simply “free”.

Some (but not all) open source licenses contain a concept called copyleft. This is the requirement that if you create a derived work from the open-source software, the derived work must carry the same license. This makes the license infectious. For example if you download a copylefted application whose licensing terms allow source code to be freely distributed, then make some changes, you are free to sell the result as a commercial product – but the source code for your product must also be freely available and redistributable.

The notion of copyleft was invented by Richard Stallman, who many years ago released several applications into the public domain and became frustrated when he saw companies create products out of them. He didn’t mind that the companies were profiting commercially from his work – but he found it intolerable that the companies would copyright the modified sources and refuse to grant him access. He created the notion of the copyleft license – backed by copyright law – to enable him to release his code to the public without enabling others to create derived closed-source products.

Some people share Stallman’s feelings – they don’t want commercial enterprises creating proprietary works from their free code, and include the copyleft notion in their licensing terms. Others don’t care, and license their works more permissively.

The most well known copyleft license is the General Public License (GPL). If you create a derived work from GPL software, you can still sell it commercially, but your derived work must also be covered under the GPL – and therefore you must make your source code available.

Rule #3 is therefore: If you include copylefted components in your application (i.e. components whose licensing terms include the copyleft concept), then be careful – your entire application may have to be covered under the same licensing terms or you will be in violation of copyright.

Here is a list of common open-source licenses and a summary of their terms (including whether each one is a copyleft license or not):

http://www.gnu.org/licenses/license-list.html

It’s important to understand the precise conditions under which including a copylefted component makes your application a derived work (and hence “infects” your licensing terms). For example if you publish a CD containing several applications, one of which is covered by the GPL, that does not make the CD a derived work that must also be covered by the GPL. Your program must be intimately coupled to the copylefted component in order for it to be considered a derived work. The rules are spelled out clearly in the GPL Frequently Asked Questions list:

http://www.gnu.org/licenses/gpl-faq.html

For example, if you write a program in a language whose implementation is licensed under the GPL, your program is not infected – unless your program actually links dynamically with GPL libraries. (The FAQ goes into great detail, including a discussion of plugin architectures and their licensing implications.)

Let’s work through an example. Say you are working with Microsoft’s CAB (Composite UI Application Block). It contains the following clause in its licensing terms:

[You agree] that you have no right to combine or distribute the Software or modifications with other software or content that is licensed under terms that seek to require that the Software or modifications (or any intellectual property in it) be provided in source code form, licensed to others to allow the creation or distribution of derivative works, or distributed without charge.

Would it be okay to incorporate log4net or not? Let’s work through the rules. If log4net was in the public domain, you would be free and clear. But it’s not – it’s licensed under the Apache Software License. However that license is a non-copyleft, permissive license that enables free use of log4net in commercial applications. Therefore it does not “seek to require” anything at all, so it is not in violation of Microsoft’s terms. So you are out of the woods.

public class ProductHelper {

    private Product _product = null;

    public ProductHelper () {
        _product = null;
    }

    public ProductHelper (Product product) {
        _product = product;
    }

    public void setProduct (Product product) {
        _product = product;
    }

    public Product getProduct () {
        return _product;
    }
}

That’s not really abstraction, since ProductHelper is at the same abstraction level as the underlying Product class. It’s like building a kitchen table out of, well, another kitchen table.

It’s also not encapsulation. If all the instance variables in a class have getters and setters, you’re not really “hiding” anything.

Some programmers argue that it’s good to create Helper or Wrapper classes when you need to access classes not under your control – for example if the underlying classes are generated Web Service stubs. But that argument is misguided. Unless the Helper or Wrapper classes are truly at a higher level of abstraction (i.e. provide a simpler interface to the underlying functionality), any changes to the underlying classes will still require you to update the client code, plus you’ll have to update the Helper classes as well.

A good tipoff that a piece of code has too many non-abstract abstractions is when many of the classes (or namespaces) are called things like “Helper”, “Wrapper”, “Manager”, “Engine”, or other names that don’t really correspond to domain objects. That’s when it’s time to dump the Kool-Aid and start simplifying the class hierarchy.

So far I’ve evaluated ExtremePlanner and VersionOne . Both are very nice tools. VersionOne is much more expensive at $2500 for the 5-user edition versus $500 for the 5-user version of Extreme Planner, although VersionOne also offers a subscription pricing model starting at $35/user/month.

VersionOne is much more complete and polished, although I find ExtremePlanner strangely compelling. ExtremePlanner’s user interface is crisp, simple and clean, and has the sort of lightweight design you might expect from an XP enthusiast. I keep coming back to it when I want to draft new stories. But VersionOne looks like it might be better for large projects and organizations. (For example it has a nice concept of themes that can be used to organize stories – i.e. story themes, not user interface themes.)

Both products disappointed me when it came to reporting facilities. I was hoping that after entering stories, tasks, resource assignments, and task status information I would easily be able to produce slick reports showing projected completion dates for each iteration, resource utilization, and so on (the kind of reports Microsoft Project generates). But neither program is very exciting on that front. ExtremePlanner’s reporting capabilities are minimal – I suppose to be expected for the price. VersionOne offers a lot more, but the reports aren’t very useful until you’ve been using the system for a while and enter a lot more data. (Unfortunately by then the 30-day trial period is over, and it’s too late to dazzle management with the sexy reports, which is what would have helped get the software purchase approved.)

I’ve also experimented with using SourceForge as an XP support tool, entering tasks into the Sourceforge tracker and adding a custom string field for the stories. The stories are entered as allowable values for the custom string field, and show up on a drop-down menu when entering tasks. This solution works, but is klunky and doesn’t behave well if you have lots of stories.

So right now, I’m having a hard time justifying the purchase of any of these applications. The tool with the best price/performance seems to be emacs (or maybe Microsoft Excel).

Other experiences, recommendations or opinions?
movie free clips trannymaker windows free moviemovie halley porn berryfind to vhs hard movieshenati moviesmovie soundtrack holes therentals hollywood moviemovies homemade porno Map

DataTable fooData = new DataTable ();
OleDbConnection dbConnection =
  new OleDbConnection
    (@"Provider=Microsoft.Jet.OLEDB.4.0;"
     + @"Data Source=C:\BAR.XLS;"
     + @"Extended Properties=""Excel 8.0;HDR=Yes;""");
dbConnection.Open ();
try
{
    OleDbDataAdapter dbAdapter =
        new OleDbDataAdapter
            ("SELECT * FROM [foo$]", dbConnection);
    dbAdapter.Fill (fooData);
}
finally
{
    dbConnection.Close ();
}

If you want to process the data row by row rather than snarfing it into a DataTable, you can do it this way:

OleDbConnection dbConnection = new OleDbConnection (@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\BAR.XLS;Extended Properties=""Excel 8.0;HDR=Yes;""");
dbConnection.Open ();
try
{
    OleDbCommand dbCommand = new OleDbCommand ("SELECT * FROM [foo$]", dbConnection);
    OleDbDataReader dbReader = dbCommand.ExecuteReader ();

    // Say we are interested only in the columns "YearOfBirth" and "Country":
    int yearOfBirthIndex = dbReader.GetOrdinal ("YearOfBirth");
    int countryIndex = dbReader.GetOrdinal ("Country");

    while (dbReader.Read ())
    {
	string yearOfBirth = dbReader.GetValue (yearOfBirthIndex).ToString ();
	string country = dbReader.GetValue (countryIndex).ToString ();

	// ...
    }
}
finally
{
    dbConnection.Close ();
}

But what if you don’t know the name of the sheet you want to read? As you can see from the examples, the ADO.NET interface requires you to name the worksheet – but in many cases you just want to read the first worksheet regardless of its name. It would be cool if ADO.NET provided a suitable notation like this:

// I WISH THIS WORKED
OleDbCommand dbCommand = new OleDbCommand ("SELECT * FROM [0#]", dbConnection);

… but it doesn’t. You must tell ADO.NET the specific name of the sheet you want to read. The solution is therefore to read the spreadsheet schema to find out the sheet names, thus reducing the second problem to the first one, like this:

OleDbConnection dbConnection = new OleDbConnection (@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\BAR.XLS;Extended Properties=""Excel 8.0;HDR=Yes;""");
dbConnection.Open ();
try
{
    // Get the name of the first worksheet:
    DataTable dbSchema = dbConnection.GetOleDbSchemaTable (OleDbSchemaGuid.Tables, null);
    if (dbSchema == null || dbSchema.Rows.Count < 1)
    {
        throw new Exception ("Error: Could not determine the name of the first worksheet.");
    }
    string firstSheetName = dbSchema.Rows [0] ["TABLE_NAME"].ToString ();

    // Now we have the table name; proceed as before:
    OleDbCommand dbCommand = new OleDbCommand ("SELECT * FROM [" + firstSheetName + "]", dbConnection);
    OleDbDataReader dbReader = dbCommand.ExecuteReader ();

    // And so on...
}
finally
{
    dbConnection.Close ();
}

The main quirk about the ADO.NET interface is how datatypes are handled. (You'll notice I've been carefully avoiding the question of which datatypes are returned when reading the spreadsheet.) Are you ready for this? ADO.NET scans the first 8 rows of data, and based on that guesses the datatype for each column. Then it attempts to coerce all data from that column to that datatype, returning NULL whenever the coercion fails!

I suppose that makes a twisted kind of sense if you have spent a lot of time working with relational databases, but there are some unfortunate consequences of this design which aren't obvious at first. For example, say your spreadsheet contains the following columns:

YearOfBirth    Country	PostalCode
1964	       USA	10005
1970	       USA	10001
1952	       Canada	K2P1R6
1981	       Canada	L3R3R2
1974	       USA	10013

ADO.NET will correctly guess that the YearOfBirth column is numeric, and that the Country column is of type string. But what about the PostalCode column, which contains a mix of numbers and strings? In this case ADO.NET chooses the type based on the majority of the values (with a tie going to numeric). In this example 3 of the 5 postal codes are numeric, so ADO.NET will declare the column to be numeric. Therefore it will attempt to cast each cell to a number, which will fail for the Canadian postal codes - which will therefore come out as NULL values. Ha ha. Isn't that fun?

Even more entertaining, there is absolutely no way to make this 100% reliable - although with some pain, you can improve the situation. Here's what you need to do. First add the "IMEX=1" option to your connection string like this:

OleDbConnection dbConnection = new OleDbConnection (@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\BAR.XLS;Extended Properties=""Excel 8.0;HDR=Yes;IMEX=1;""");

That tells ADO.NET to honor the following registry key when reading the spreadsheet:

Hkey_Local_Machine/Software/Microsoft/Jet/4.0/Engines/Excel/ImportMixedTypes

This registry key tells ADO.NET what to do when it encounters mixed types in the first 8 rows. It can either be set to the string "Majority Type" (for the default behavior) or to "Text" (which forces the column to be of type string). Note that you are still screwed if the first 8 postal codes are numeric and the 9th is Canadian. (Not to mention that the "Text" option invokes handling that fails on strings over 255 characters, but let's skip that for now.)

There's also a second relevant registry setting (which is honored regardless of the IMEX option):

Hkey_Local_Machine/Software/Microsoft/Jet/4.0/Engines/Excel/TypeGuessRows

That says how many rows to scan to guess the datatype. The default is 8, but you can set it anywhere from 0-16 decimal (0 meaning "scan the first 16384 rows", and all other values meaning what they say). Putting this all together, the most reliable way to read a US/Canadian postal code is to use the following registry settings:

TypeGuessRows = 0
ImportMixedTypes = Text

That's pretty close to perfect, although it will still fail if the first 16384 postal codes are numeric and any of the subsequent ones aren't.

This is a Bad Design for so many reasons I don't know where to start. First, the behavior of the spreadsheet importer should not depend on global registry settings - that is just inviting mysterious, data-dependent errors whenever other applications or users change those settings. All of those settings should be in the connect string and nowhere else. Second, there should be an option to say "I'm not sure what data is coming, but I want all of it - please coerce everything to something universal like an arbitrary-length string". Third, the interface should be stream-based, not file-based. If you are reading the spreadsheet data from the network, you shouldn't have to save it to a temporary file in order to parse it. Fourth, you shouldn't have to read the spreadsheet schema if you just want to select the worksheet by index (e.g. you want to read the first worksheet, whatever it happens to be called).

For an example of a nice interface for reading and writing Excel spreadsheets, check out Jakarta POI (an open source Java library).

Of course you can try to have it both ways – making 20% of features easily accessible and hiding the other 80% behind an “Advanced” button. But that often doesn’t work well. If the Advanced functionality is so complicated that only .000001% of users can understand it, you still lose. Personally I’ve always hated stereo systems with an “Advanced” flap with 200 teeny knobs behind it. But maybe that’s just me. (I admit it’s the only solution if your end-user application is also a platform, like Microsoft Excel.)

Linus Torvalds is one of the greatest platform designers of all time, and thinks of everything as a platform. I think that’s why the Linux kernel is so modular, and why Linux has been so successful as a server operating system. Now we need some “user interface thinkers” to work over the Linux desktop. I predict it will happen, and we’ll be seeing Linux desktops moving into the mainstream in the next 5 years.