Response: "Agile is treating the symptoms, not the disease" by Ted Neward

Ted Neward, whom I’ve known for about 4 years now, wrote a piece calling out all the complexity that is in the line of business software space these days.

This post is not to say that I agree or disagree, but it is a refreshing blog post to read.  I love discussion like this.  As the CTO of a consulting company that embraces Extreme Programming for project delivery, I’m continually trying to get better at delivering high-quality, maintainable software.

When reflecting on what Ted calls out that is necessary for my people to know, I’ll quickly add to the list:

  • · 7zip
  • · aspnetmvc
  • · AutoMapper
  • · cassini
  • · castle
  • · CruiseControl.NET
  • · exceptioneer
  • · FxCop
  • · gallio
  • · msdeploy
  • · mvccontrib
  • · naak
  • · nant
  • · nantcontrib-0.85
  • · nbehave
  • · ncover
  • · ndepend
  • · nhibernate
  • · nunit
  • · rhinomocks
  • · SourceMonitor
  • · structuremap
  • · subversion
  • · tarantino
  • · watin

The funny thing is, we are building tools to make delivering software easier, so we have other things added to the .Net framework.  At some point, Microsoft and Oracle need to take a good look at .Net and Java and see how they can raise the abstraction level a bit so that the technical business analyst can have a hope of a small program.

Just like DRM in the music business has found (>80% of music pirates could not be forced to pay for the music), >80% of technical business analysts will not use .Net or Java for their small little app.  They will walk away and not write the app.  They will instead add just a few more macros to that huge Excel spreadsheet.

Udi Dahan to come deliver his SOA & DDD course in Austin

Udi Dahan is delivering his Advanced Distributed Systems Design (SOA & DDD) course in Austin for the second time.  Headspring is hosting the training and is happy to offer this course for those in Austin and those willing to travel to Austin.

November 30 to December 4 of 2009 are the dates of the training.  Go to the Headspring training page to sign up.  Below is the breakdown of the course.

Module 1: Distributed Systems Theory

Decades of distributed systems development have taught us many lessons. In this module we’ll cover many historical mistakes as well as proven best practices for scalable and robust design. Topics include:

  • 8 fallacies of distributed systems
  • Transactions

Module 2: Coupling: Platform, Temporal, & Spatial

Loose coupling has become the watchword of complex systems development, yet few understand its multiple dimensions. In the module we’ll be covering the three different dimensions of coupling as well as patterns for dealing with them.

  • Platform Coupling – XML/SOAP
  • Temporal Coupling – Synchronous/Asynchronous
  • Spatial Coupling – Endpoints/Topics

Module 3: Asynchronous Messaging Patterns

Although scalability is achieved through the use of asynchronous message passing, more advanced message exchange patterns are required to handle today’s complex integration scenarios. This module will cover the most commonly used patterns:

  • One way
  • Correlated Request/Response
  • Publish/Subscribe

Module 4: Bus & Broker Architectural Styles

Enterprise Service Buses are all the rage these days. In this module we’ll be covering what’s the difference between the Bus architectural style, and the more well-known Broker, found commonly in many EAI projects. Topics will include:

  • Architectural advantages and disadvantages
  • Technological advantages and disadvantages

Module 5: SOA Building Blocks

One of the goals of SOA is to develop systems which are more closely aligned with Business. In this module we’ll be covering an analysis methodology from moving from the business domain to executable systems that comply with all the principles of loose-coupling.

  • Business Services
  • Business Components
  • Autonomous components & Queues

Module 6: Scalability and Flexibility

In order to enable agility, services must be able to scale up, out, and down quickly. In this module we’ll see how autonomous components can be configured including transactional and durable aspects of message handling.

  • Configuring autonomous components
  • Scaling up and out

Module 7: Long running processes

The distributed communications patterns wouldn’t be complete without a discussion on orchestration. In this module we’ll see how to manage the state of long-running distributed communication flows as well as:

  • Encapsulating process logic
  • Advantages & disadvantages of orchestration

Module 8: Service / AC Solutions

As developers go to implement autonomous components, guidance is required as to which concepts need to implemented in which project, what dependencies are there between projects, and how to bridge the worlds of messaging, business logic, and reporting. Topics include:

  • Messages + Handlers
  • Databases

Module 9: Service Layer – Domain Model Interaction

Logic-rich services require the use of advanced techniques for logic componentization. The Domain Model Pattern enforces a high level of Separation of Concerns, yet it must eventually be connected with Service Layer code that supports many concurrent users. In this module, the topics covered will include:

  • Domain Model introduction
  • Testing Domain Models
  • Optimistic, Pessimistic, and Realistic Concurrency Models

Module 10: High-Performance Domain Models

The strong separation between the Domain Model and the database which stores and retrieves its data may enable a high level of testability, yet often causes performance problems. In this module, we’ll see the various aspects impacting the performance of persistence:

  • Transactions and Isolation Levels
  • Lazy Loading, Eager Fetching
  • Databases Tips & Tricks

Module 11: Web Services and User Interfaces

The ease of interacting with users over the web drives the need for service to UI interactions. Also, many integrations require exposing synchronous web services to customers. In this module, we’ll see what is required in both cases:

  • ASP.NET 2.0 Asynchronous Tasks
  • Rich Internet Applications and Services
  • Web Services for integration

Module 12: Smart Client / Service Interaction

The publish/subscribe semantics with which services communicate require smart clients to perform a great deal of background work. Also, certain service contracts lead to more performant clients. In this module, we’ll cover the first part of these interactions:

  • Multi-threaded client challenges
  • Client-friendly Service Contracts
  • Service Agents and Client Repositories

Module 13: Notifications & Smart Clients

After Message Handlers in the Service Layer create or update the relevant Model objects in the client Repository, Supervising Controllers are in charge of getting Views to show the updated data. In this module, we’ll describe the parts and interactions of these flows:

  • Client-side Model Objects
  • Supervising Controllers
  • Views and their Interfaces

Module 14: Commands & Smart Clients

Capturing user intent and synchronization between views are at the core of smart clients. After describing solutions that use Events on the View Interfaces, the Command Pattern will be introduced to further decrease coupling between Supervising Controllers. In this module, we’ll describe the parts and interactions of these flows:

  • View Interfaces, and how Entity Cloning affects them
  • Supervising Controllers and clone reconciliation
  • Commands, and Event-Based programming

MvcContrib working on Portable Areas

This is a pretty short post, and it is just enough to announce some plans on the MvcContrib roadmap.

Portable Areas

What is a portable area?  As you know, ASP MVC 2 is going to ship with an implementation of areas where an area can either be in in a single project or separate projects.  MvcContrib already has an Embedded View ViewEngine, which lets views be embedded as resources in an assembly.  The next step is to take an MVC2 area, wire in the embedded view engine, and compile it to a single assembly.  Then, you can publish your area as an assembly to distribute any number of controllers and views.  This can be used to distribute multiple pages that all work together.

I expect control vendors to use portable areas to make their rich control suites work with ASP MVC.  After all, when registering the portable area at application start, the routes are essentially being registered.  Even if there are no top-level pages in the area, it would be really easy for a control vendor to supply an area allowing the developer to type:


The area has multiple controllers and views, and they can be wired into an application in many ways.

Call for participation

If you are interested in participating in the development of Portable Areas within MvcContrib, please join the discuss list and create a GitHub fork of MvcContrib.