Sunday, December 28, 2008

Stuff that Jeremy do like


    How does this guy get the time to read and try all this stuff.
    Excellent and cool list.

    1. New Architectural Guidance coming from patterns and practice.

    2. The general direction of xUnit
    My Comment: I will stick with MSTest right now.

    3. AAA syntax and mocking styles in Rhino Mocks and Moq.
    My Comment: Loved it. I liked more Moq for its simplicity but keep Rhino Mocks as back up.

    4. Nate Kohari's approach to convention based setter injection in Ninject
    My Comment: Interesting. I am okay with Configuration or Custom Attributes approach for AOP. Convention approach sounds little backward but can be handy in certain situations.

    5. Autofac’s extensibility Model
    My Comment: Another DI framework

    6. StructureMap

    7. New Language features in .NET 3.5
    1) Lambda expression
    2) Var
    3) Object Initializer
    4) Collection Initializer
    5) Extension Methods
    6) Anonymous Types
    7) Auto Implemented Methods
    8) Partial Methods

    8. Expression Tree

    9. JQuery
    My comment:- I am going to buy a book to master this javascript framework.

    10. MassTransit
    My Comment:- It sounds more like command pattern. There may be more. I need to investigate more into this.

    11. Linq to NHibernate and Linq in general of course
    My Comment: Since Generics in .NET2.0, LINQ is best thing that has happened in .NET3.5

    12. More powerful Auto Mapping and convention support for Fluent Nhibernate
    My Comment:- I will stick to LINQ for SQL time being. I hated the XML configuration for Nhibernate as it was error prone. Active record was a compromise.

    13. Bellware's SpecUnit assertion extensions
    My Comment:- Makes unit test more readable and maintainable.

    14. Fluent Fixture

    15. Prism Project
    Composite Application Guidance for WPF

    16. MVC
    My Comment- MVC rocks

    17. Common Service Locator

    18. Any Tool written by Jet Brains
    Resharper Rocks

    19. AutoMocker and Interaction Context base Classes

    20. Dino Esposito's latest book on .Net architecture
    My Comment:- I did a quick reading at book store. My rating 5 out of 5.

    21. Ben Scheirman's new fluent API for testing routes in MVC

    22. Rake Build Tool

    24. DotNetRock Guest List

Saturday, December 27, 2008

CLSA .Net 3.6 Overiew

I have added the Expert 2008 Busines Objects to my 'to read' list.
I also share the Rocky's view that UI future belongs to WPF/Silverlight/XAML .

Subsystems of CSLA.NET 3.6

1. 90% of the code will be shared between .net and silverlight applications,with less than 10% code being different.
My Comment - Amen

2. Databinding
My Comment -Databinding reduces the plumbing between UI and business objects. That is something our frameworks should exploit

3. Object Status Tracking(new, changed , marked for deletion)
My Comment - Cool

4. Standardization of business and validation rule processing

5. Integration with, and simplification of , .NET authentication model.

6. Undo capabilities
Not too exciting feature for Web Based applicaions.

7.Enhanced support for LINQ queries against your business model.
My Comment--
LINQ is for major enhancement in .NET 3.5 platform since Generics in .NET 2.0
LINQ is something definately that one should exploit.

8. Aysnchronous data access and Asynchronous Validation Rules
My Comment--
I can understand that one can run the queries and expect to notified by the system.Aysnchronous Validation. Beats me.

These subsystems are exposed through a set of base classes from which you inherit to create your business objects. These base classes enable a set of object stereotypes:
1. Editable Root
2. Editable Child
3. Dynamic list -- Not for
4. Read-only root
5. Read-only Child
6. Name/Value List
7. Command

My Comment-
Only Command Pattern sounds interesting other bases classes sounds more like noise in the framework.
It is interesting how one can abstract Command Pattern in the framework.

Mobile Objects-
My Comment - With Remoting out of favor, Mobile objects sound more like a philosphical approach than tactical solution.

CSLADataSource & DataMapper
My Comment -- Having burnt my fingers with Object Data Source, having Custom Object Data Source is way to go. With Mobile Objects out of favor, you need DataMapper to convert proxy objects/Data Objects into real Business Objects.

Simplifies launching,suspending and resuming a workflow instance.

CSLA.Net for SilverLight

Thursday, December 25, 2008

Moq,RhinoMock and Lambda(AAA) expressions

Last time I played with RhinoMock , I was in state of shock and awe. I was awed because it improved my design. It requrired that the code under test should to be isolated from rest of application. That was done using Interfaces . Contract based programming is always best way of programming. I could test behavioral aspect of my code.It would have been little difficult using xUnit framework. It was almost creating a simulation flight envrionment and enjoying the pleasure of real flights.

I was also shocked by the fact that my behavioral tesing Line of codes were many times more than code under test.

I was left in no doubt that Mocking is very powerful and advance technique of TDD. Also at the same time, It will make selling TDD difficult to people new to programming.

Hopefully Lambda expression may help in that direction.

Sunday, December 14, 2008

Design and Testability

Good Question.

Can you write effective unit tests without knowlegde of designing ?
I think that Jeremy is right in saying no.
OOP is all about design.
Concepts like Object, Collaboration and Messaging or Inheritance,Polymorphism and Encapsulation are all about design.

If a person does not understand OOP,Domain Driven Design, he can hardly write effective unit tests.

In OOP , one has to take 100 design decisions(which code goes to which class or layer) per day.

TDD is advance concept to master. One has to learn OOP and Design Patterns before that.

Monday, September 22, 2008

97 Things Every Software Architect Should Know

Some highlights:
1. Don't put resume ahead of requirements

SOA == WebSerices came from above.

2. Chances are you biggest problem is not technical

3. Learn from Architect of Buildings.
Survic is not going to like this one


My Additions:
1. User Interface rules. Ignore it at your peril.

Saturday, August 23, 2008

Houston, We have a memory leak

Recently I was investigating a memory leak with other colleagues. The windows service was giving out of memory exception. This windows services in short does lot of xml processing and serializes xml into business objects.

Naturally, first our needle of suspicion fell upon usual suspects i.e.. XMLDocument and XMLReader. Calling close and set them null multiple times didn’t help. While googling for a strong evidence against XMLDocument, I stumbled upon a clue that we were looking at wrong places and culprit may be XMLSerializer class. I googled for a connection between XMLSerializer and found tons of damning blogs and articles.

It is even documented by Microsoft in their MSDN documentation
To increase performance, the XML serialization infrastructure dynamically generates assemblies to serialize and deserialize specified types. The infrastructure finds and reuses those assemblies. This behavior occurs only when using the following constructors:


XmlSerializer..::.XmlSerializer(Type, String)

If you use any of the other constructors, multiple versions of the same assembly are generated and never unloaded, which results in a memory leak and poor performance. The easiest solution is to use one of the previously mentioned two constructors. Otherwise, you must cache the assemblies in a Hashtable, as shown in the following example.


A very good article about debugging memory leaks

A nice website about memory leaks

There a knowledge base article about this problem

Are we facing a a virtual bytes leak, a native leak or a .NET leak
Important Counters

1.Process\Private Bytes
2.Process\Virtual Bytes
3. .NET CLR Memory\# Bytes in all heaps
4. .NET CLR Memory\# Total committed bytes
5. .NET CLR Memory\# Total reserved bytes
6. .NET CLR Loading\Current Assemblies

If the curves for private bytes and bytes in all heaps diverge we either have a "native leak" which means that we have a native component that is leaking (in which case debug diag would be the next step), or we have an assembly leak.