The Castle Project has finally released its version 1.0 RC3 today.  It has been a long time coming but not for lack of work.  I am on the development discussion list and there is a lot of activity, much work has gone into this release.

Details on the release from the blog of the Castle Project founder:

ActiveRecord

• Multiple db support without the need to extend ARBase
• Refactored validation support to use the new Castle Validation
• InPlaceConfigurationSource.Build() which is handy!
• Added HqlNamedQuery
• Lots of bug fixes

DynamicProxy

The RC3 is the first to include DynamicProxy 2 which has support for generics and is much much faster than version 1

MicroKernel/Windsor

• Support for generic collections
• Changed to use DynamicProxy 2
• Added some sugar to IKernel and IWindsorContainer add/resolve methods
• Child container support was improved, but still need some review – you?ve been warned
• Added a simplistic eval support, you can do <?eval $BaseDirectory ?> on your config
• Both DefaultKernel and WindsorContainer now implement IServiceProvider

MonoRail

• Added Cache support (see the new Cache attribute)
• Added IsPost/IsGet/IsPut/IsHead to Controller
• Added Auto Form Validation
• FormHelper is nearly perfection, still missing support for selects with multiple enabled
• Support to register several view engines at once (bye composite view engine) – this is not as good as I?d like it to be. There?s no co-op among them..
• Added handful of view components
• Added support to test controllers, viewcomponents, wizard steps without the need to bring the ASP.Net to the table
• Added JS generation support, and UpdatePage/UpdatePageTag view components
• Format support on set operations, for example $Form.Select(?price?, [1..100], ?%{textformat=?C’}?) is going to render the select elements with currency format
• Added PaginationHelper.CreateCustomPage which is the most optimized way to deal with pagination
• Added DiggStylePagination ViewComponent, based on Alex Henderson work
• Added the following members to SmartDispatcherController (validation related) ValidationSummaryPerInstance : IDictionary, GetErrorSummary(object instance) : ErrorSummary, HasValidationError(object instance) : bool
• Added ViewComponentDetails attribute (just like ControllerDetails)
• Added ViewComponentParam attribute which tells MonoRail to bind the arguments as properties on your view component – reducing repetitive code rules
• Added UrlHelper/UrlBuilder concept

Aspect#

Is out?

Components

• Added Castle.Validator
• Added Castle.DictionaryAdapter – still puzzled by this one
• Improved Binder (another re-write of its implementation)

Other

• Created the using.castleproject.org
• Created the api.castleproject.org
• Initial integration between the Castle.Services.Transaction with MS? System.Transactions
• Created Castle.Core

Well, basically that was it. We?ve been busy.

For those who don’t know what the Castle Project is, it is a set of libraries for implementing a Model-View-Controller (MVC) framework in .NET.  The key piece for this is MonoRail with ActiveRecord handling the models.  Most of the time we hear about Ruby on Rails and its MVC implementation but Castle does this on .NET. 

I did an interview with Hamilton Verissimo, founder of the Castle Project, for InfoQ last week.  Hamilton is a sharp guy and has lead the core team to produce a great open-source project.  I am working on a project using MonoRail and it is very nice to produce a web application this way.

This may be old news to most people out in the Microsoft Architecture world but it is news to me.  Microsoft has a web site called Skyscrapr and it is dedicated to the topic of Architecture.  

It appears to be a portal to all things Architecture related on Microsoft web sites.  I spent some time today going through the resources on the site and there is a wealth of information and links to many, many other resources.

The topic of Object Relational Mapping or O/RM can be found all over the web in various weblogs and forums debating whether O/R-M was a useable technology or not and the pros and cons to using it. 

Ted Neward always has great posts on technology from both the .NET and Java perspective.  Ted knows both sides very well and it is refreshing to see someone is not an anti-Microsoft person arguing against a non-Java person, which gets very old.

O/RM holds the promise of encapsulating our entire database schema into objects, which is much easier to understand from an object hierarchy perspective.

Ted has had some interesting posts on O/RM in the past, one in particular relating O/RM as the Vietnam of Computer Science.  .NET Rocks recently had a show dedicated to O/RM call the “ORM Smackdown” where Ted Neward and Oren Eini had a debate about O/RM.  It was a good show and Ted had a follow-up post to the show, which is worth a read.

Successful O/RM Project

The point of this post is not to debate whether O/RM is good or bad but to show any technology can be successful if done correctly.   There are many ways to do something correctly, this just happens to be an overview how we did it.

I am a consultant and one of my current projects is for a major pharmaceutical company.  The project is meant to revolutionalize the way drugs are manufactured.  O/RM is a technology we use to assist developers with focusing on our entities (business objects) and how they interact with each other instead of how to use ADO.NET to interact with Microsoft SQL Server 2005.  The software is written in C# and developers realize the benefits of what O/RM can do for them by making our entities native C# classes.

We built a custom application to generate stored procedures, entity classes and a data access layer.  At the heart of the application is an XML document that defines how the entities are related, this document removes the flat nature of the SQL schema we use.  For example, we may have an entity called Customer which has an address, order history and contact information.  Each of these parts of  the entire Customer may live in it’s own table but from the object perspective each may be a property or collection, part of the complete Customer.

Our tool allows the user to connect to a database which in turn reads the table schema, views, indexes, stored procedures and functions from the the database and loads everything into memory.  The XML document is read in and is validated against the database for schema changes and automatically updates itself.

The combination of this document and the in-memory database information allows the user to generate a complete data access layer and entity classes for the developer to use. 

Manageability

My description is very vague the result is real.  A complete and clear set of classes representing an entity hierarchy which allows the developer to use domain specific objects and not be concerned with SQL in the least.  The data access classes are proven, the entities are complete.  Schema changes and stored procedures are integrated into the nightly build process.  We have the best of both worlds with having a complete object hierarchy representing our domain and use of stored procedures to get away from the dynamic SQL issues.

Granted, this is not a solution for all situations but it does work in ours and it could work in many others.  The code generator we used was written from scratch but if we had to do it again we would probably use CodeSmith and create a family of templates.  The technology used to generate code is really irrelevant, but the techniques are solid and have worked for a few years now.

Conclusion

Overall our implementation is very clean and works very well.  I know we would change some of the implementation but the overall design would pretty much be the same.   I welcome questions about our implementation or suggestions how you had a successful O/RM deployment and successfully maintain that deployment.

I found this article, Escape Metropolis: Bridging the Divide Between Developers and Architects an interesting read.? I am both an architect and a developer and understand the distrust a developer has for an architect.? Since developers are the ones who produce the actual code they feel they are the real workers.? I strongly believe an Systems Architect really needs to be an active developer to do a good job and fully understand the problem at hand.? I know I have been in the role of architect and only because I was also a developer could I fully prove what I proposed was the right way to go.? It has happened where the proposed solution ended up being the wrong one and the reason it wasn’t a problem was because it was found in the “proof of concept” phase, which is always needed. I have posted about this in the past here. Technorati Tags : System Architect, Microsoft

I work at my day job as a System Architect in a small company who creates commerce applications. I design the plumbing of applications and I write code to test the design. This is not true of all architects, there are some who are behave more like prima donnas, thinking this is not their job. They create charts with some fancy software and present the design to a team and walk away. This does not work. How can a design be so complete as to work this way without proof of concept? Johanna Rothman is a writer who I enjoy reading her books and in particular her blog about Managing Product Development. She had a post recently about this subject where she makes the statement that Architects must write code. She also calls out to a book from Pragmatic Bookshelf called Practices of an Agile Developer that call these types of Architects “Powerpoint Architects”. I cannot agree more about this labelling. We went through a complete redesign and are deep in our rewrite of our latest commerce application. I worked with another Architect in the initial design and we spent many weeks on an iterative architecture design, we wrote code to test our theories and reworked the architecture based on the results. The code was not production code but prototype code to prove the design. I think this was the key to our good design, without this we would have gone down the wrong path in several areas for various reasons which relied on the current framework available at the time of design versus the framework to be available at key phases of the implementation. As an example, we had some design decisions to make when we were using the .NET Framework 1.1 and looked ahead to version 2.0. Knowing 2.0 had some great features that would supplement our design and take it a different direction we had to rework the design committing to version 2.0. Our prototype code was done with a beta version of 2.0 and looking back it was a key design decision that we are better for now. If we had not taken the time to prove some initial points we may be using version 1.1 today and be months behind because of the areas 2.0 saved us time in. A good architect needs to write code, period. A good design needs to be proven, it is a culmination of experience and proven results. Technorati Tags : System Architect, Microsoft

I don’t like to post a link to someone else’s blog or web site without having a good reason.  Joel Spolsky of FogCreek Software and the popular Joel on Software web site recently posted about usability.  His post goes hand-in-hand with my post about product complexity from yesterday.

Joel has a book out on user interface design and his company’s software, FogBugz, has a beautiful user interface that is truly “usable”.  I think his post is worth a read.

This is an interesting article I came across. You should get the jist from the title. I think this applies to software as much as products. Too many companies try to jam as much functionality into a piece of software that it becomes too bulky and complex which results in users avoiding it. Take Microsoft Word for example, which is the biggest piece of bloatware on the market today. What percentage of features does the average user actually use? I would guess and say 5%. I know I use very few features and avoid Word as much as possible.

Half of all malfunctioning products returned to stores by consumers are in full working order, but customers can’t figure out how to operate the devices, a scientist said on Monday.

The moral of the story should be that we make it a point to build better software with a cleaner user interface and actually make use of usability testing. I think we can take a lession from the folks at 37Signals or Google for their intuitive user interfaces. There is actually a great book called Don’t Make Me Think : A Common Sense Approach to Web Usability by Steve Krug that takes a commonsense approach to making software intuitive and actually usable.

read more | digg story

I don’t know if I am late to the party or not but I just discovered an online magazine called ObjectView.  The magazine is distributed as PDF files and is targeted toward hard core developers.

The magazine appears to take a neutral stance on platforms and languages with recent issues talking about Ruby, Ruby on Rails, Java, .NET and AJAX.  There is ample focus on programming issues such as Agile Development, writing specs, unit testing, extreme programming and refactoring amongst other topics.

ObjectView attracts some well-known writers as well such as Scott Ambler, Amy Hoy and Richard Vaughn. 

I am not affiliated with the magazine, just happy to find this gem.

Technorati Tags : ObjectView

Microsoft seems to be focusing more on architecture these days.  There is a new podcast available on the Microsoft Architecture site.  The site has some great content and have also created a blog too.

The latest edition of the Microsoft Architecture Journal #5 is out now.   This is one of the best sources of the current state of systems architecture around and the price is right.

The Microsoft Architecture Resource Center hosts this journal and also has a lot of great information on architecture subjects and links some blog worth reading.