The .NET and RRD implementations were built in the controlled environment of the lab. During their development, the team members carefully tracked and the auditor recorded the time spent building each of the core elements of the ITS system. Since the Oracle 9i and SQL Server 2000 databases were fully installed and configured in advance, neither team had to spend time creating database schemas.
The WSAD implementation, on the other hand, was built later under special circumstances:
• The J2EE team had already built the application once.
• The team did not work in the lab, so the auditor could not monitor their time. Instead they carefully tracked their own times.
• The team did not reinstall WebSphere on the development or production machines.
• The team did not redevelop the handheld application.
For these reasons the auditor’s report provides productivity results only for the .NET and RRD implementations, while issuing a disclaimer regarding the WSAD results.
8.1.1 The Basic Data
The study tracked these core development tasks:
• Installing Products. This included time to install software on both development and server machines. All equipment used by the two teams initially had only a core OS installation, except for the two databases (Customer Service and Work Order) which were already installed and pre-loaded with an initial data set.
• Building the Customer Service Web Application. This included constructing the Web UI and backend processing for the Customer Service application according to the provided specification, as well as the functionality to send messages. It also included creating the Web service request that provides the ticket search functionality in the Customer Service application, and ensuring the application could be deployed to a cluster of two load-balanced servers with centralized server-side state management for failover.
• Building the Work Order Processing Application. This included building the Web UI and backend processing for the Work Order application according to the provided specification, as well as the message handling functionality. It also included creating the Web service for handling ticket search requests from the Customer Service application.
• Building the Technician Mobile Device (Handheld) Application. This development task included building the complete mobile device application according to the provided
specification.
• System-Wide Development Tasks. This category included working out general design issues, writing shared code and general deployment and testing.
The following table shows the actual time spent building the .NET and RRD implementations, in developer hours. The data come from the auditor’s report:
Time Spent Developing the ITS System, by Development Task (in developer hours)
Team / Tool Used Development Task /
ITS System Component .NET / VS.NET J2EE / RRD Customer Service
Application
40 69
Work Order Processing Application
41 59
System-Wide Development Tasks
2 29
Subtotal 83 157
Product Installs 4 22
Technician Mobile Device Application
7 16
Overall total 94 196
The WSAD implementation was created later by the same team that had previously created the RRD implementation. It was also created outside of the controlled lab setting. Hence,
productivity data for this implementation cannot be directly compared to the other two, since the team benefited from already having already built the same application once. In addition, the team did not reinstall the WebSphere software nor redevelop the handheld application for the WSAD implementation.
Nevertheless, the following table shows the relative time spent developing the WSAD implementation of the ITS system. The data come from the developers logs.
Time Spent Developing the ITS System, by Development Task
(in developer hours)
Team / Tool Used Development Task /
ITS System Component J2EE / WSAD Customer Service
Application
13
Work Order Processing Application
46
System-Wide Development Tasks
33
Subtotal 92
Product Installs n/a
Technician Mobile Device Application
n/a
Overall total n/a
Given how easily two developers working closely together can move quickly among several tasks, one should not read too much precision into the breakdown of these numbers by development task. Nevertheless, some interesting conclusions emerge:
8.1.2 .NET vs. RRD
The .NET team developed the entire system about twice as fast as the J2EE did team using RRD. This greater speed applied across all components.
One of the greatest differences was for product installation. This is not surprising, since several key server-side .NET components were already present as part of the base installation of Windows Server 2003:
• Internet Information Services (IIS), the Web server
• Network Load Balancing (NLB)
• Microsoft Message Queue (MSMQ), the message server
The corresponding components on the WebSphere side – IBM HTTP Server3, Edge Server and WebSphere MQ Server – had to be installed separately. So, of course, did the WebSphere Application Server itself, on both the development and production machines.
Another significant difference was in developing the Mobile Device piece, where the J2EE team ran into some roadblocks. (See Section 8.2.3.5 for details.)
3 As noted elsewhere, the base Linux installation included an installation of the Apache Web server, but the team chose to use IBM’s version instead.
Even within the core development (the Customer Service and Work Order applications), the .NET team was more productive. Much of the explanation may lie in the simple fact that Visual Studio.NET is the dominant.NET tool, and a developer who has worked in .NET for 3 years has probably worked on VS.NET most or all of that time. In the J2EE world, by contrast, RRD is one of many tools, and a comparatively new one at that. The .NET team was undoubtedly more experienced with their tool than the J2EE team with theirs.
Another factor may be the differing approaches taken by the two tools. VS.NET is more comparable to WSAD than to RRD: a development environment that connects you directly and explicitly to the platform on which you are developing. RRD, on the other hand, is marketed as a rapid development tool that accelerates the development process via its model-driven
approach. RRD distances the developer from J2EE, and the team found that it simplified some tasks but complicated others where low-level code access would have been desirable. In a wide-ranging development project like ITS, RRD’s weaknesses may have outweighed its particular strengths.
Although the teams did not track the time spent performing different types of tasks (such as designing a Web page vs . coding database access logic), some inferences are possible. Both RRD and Visual Studio provide excellent GUI design tools and the ability to bind data objects to fields in a page. It is likely that the two tools offered much more similar productivity in this area, and that the greatest differences lay in other aspects of application development, such as coding the Customer Service logic to create and manage new work tickets in memory.
8.1.3 .NET vs. WSAD
The .NET implementation (excluding product installation and the Mobile Device application) took approximately 10% less time to develop than the WSAD implementation (although, as noted, productivity for the WSAD implementation benefited from the fact the team had already built the same application using RRD). Though the totals are similar, the distributions differ.
The J2EE team spent much more time writing common code and much less time on tasks specific to the Customer Service application. This was also true of the Work Order Web application, though the total for that item in the table also includes most of the work on messaging.
The main reason for the higher total under “common” is that the J2EE team developed frameworks for the Web, business logic and persistence tiers. For example, their custom built base servlet class provided much of the functionality needed by all the servlets in the two Web applications. This design reduced the time spent developing individual use cases, while increased the proportion of time spent on common tasks.