DotNetKicks.com - published architecture stories

José F. Romaniello: INotifyPropertyChanged as AOP

Thu, 02 Jul 2009 18:19:31 GMT

The purpose of this post is to demonstrate several ways that to use INotifyPropertyChanged as an AOP aspect in your business entities. I will use DynamicProxy for AOP and NHibernate as orm mapper. Althought all methods can be plugged into nhibernate using tuplizer, I will skip this part until the final solution.

Exploring Code Contracts: Taking a look at Object Invariant Conditions

Thu, 02 Jul 2009 19:45:00 GMT

Taking a look at the new Code Contracts library which is out of MS Research and will be part of .Net 4.0/Vs2010. Contracts allow for many different ways to perform language agnostic code validation and in this episode we are going to focus on how to utilize the Object Invariant checking to maintain an objects state.

Do you want to analyze .NET code ?

Wed, 01 Jul 2009 00:02:34 GMT

We will look at Code analyze tool and see why it is good to use one for your codebase.

Software Industry is not matured yet - SOA Hype is an example

Thu, 25 Jun 2009 19:09:40 GMT

I have been part of software industry for a decade now. I had always heard few statements by other engineering practice expert, specially Mechanical and Civil Engineering experts saying that "Software industry is not as matured as Mechanical or Civil Engineering is."

Learning the Decorator Pattern

Tue, 23 Jun 2009 15:15:00 GMT

Taking at how we can use the Decorator Pattern in our application. The decorator pattern is a structural pattern which allows you to attach new or additional actions to an object dynamically. Using the decorator pattern provides a very clean and flexible alternative to subclassing (via inheritance) your object and thus creating an unwanted inheritance tree

Instinctive Performance Optimization Wastes Time

Tue, 23 Jun 2009 04:05:56 GMT

Some interesting observations about performance optimization. Includes real-world examples of some counter-intuitive performance optimizations and how sometimes users subjectively perceive a slower implementation as feeling faster.

The "Sim City" effect: warning signs and avoidance

Sat, 20 Jun 2009 17:21:08 GMT

Can you forsee the "Sim City" effect and can you avoid it happening?

EntitySpaces DynamicQuery Serialization Part II (WCF and Silverlight)

Wed, 17 Jun 2009 13:41:41 GMT

This stuff is hot guys and gals. We are asking Jon Davis to write an entirely new Silverlight demo that will showcase our DynamicQuery feature running under Silverlight inside the browser and hitting a WCF service on the server. We cannot wait, this is so slick . Here's another sneak peak post.

Exploring Code Contracts: Taking a look at Pre/Post Conditions

Tue, 16 Jun 2009 21:15:00 GMT

The "Sim City" effect

Wed, 17 Jun 2009 08:30:00 GMT

What happens when you turn your back on a software development project.

Throw Exceptions In Your Domain

Mon, 15 Jun 2009 17:36:55 GMT

If you have a Domain Model, you're going to have code that validates rules and checks for inconsistencies ... start with the simplest way of handling business logic errors: throw an exception.

Book review: NHibernate in Action

Mon, 15 Jun 2009 07:29:35 GMT

In this post I review the book NHibernate in Action from Manning Publications. As far as I know this is the only book that solely covers the Object/Relational Mapper NHibernate.

How choice of Data Structures and Algorithms affect Performance

Sun, 14 Jun 2009 09:39:55 GMT

Performance of the application is one of the prime requirement today. So select the optimum data structure to provide best performance...

EntitySpaces - WCF DynamicQuery Serialization

Sun, 14 Jun 2009 03:46:43 GMT

We have decided to use the WCF DataContract approach when serializing our enhanced DynamicQuery's. In our upcoming alpha release our DynamicQuery classes now live in a separate assembly that can execute on the client side along with your EntitySpaces proxies without requiring either the EntitySpaces.Core or the EntitySpaces.Interfaces assemblies. The EntitySpaces.DynamicQuery assembly (only 52k in size) is also compatible with Silverlight and can run down inside of the browser.

You're Not Your Data Access « Rob Conery

Fri, 12 Jun 2009 13:41:17 GMT

Rob discusses the tendency of .NET developers to over-engineer and urges us to focus on building good working software instead of trying to build rockets to saturn. One of my favorite posts of his.

What & Why Choose F#?

Tue, 09 Jun 2009 12:48:59 GMT

I am becoming more interested in F# lately, learning a little more on what it's all about and in my travels I have stumbled across a few links and topics on why one should use F# and what it's all about. I thought I might share. Shamefully, I personally have still been too flat out to use it myself, but hoping that will change very soon!

Learning Hudson: Setting up to run and report Unit Test results

Tue, 09 Jun 2009 15:15:00 GMT

We will be taking a look at how we can use Hudson to report our Unit Tests results after each build. We will be looking at both reporting NUnit and MSTest results and will also show how you can convert MSTest results into NUnit results in order to report all tests in a single screen.

Code Contracts Primer - Part 1: Introduction

Mon, 08 Jun 2009 19:59:27 GMT

If you are not familiar with the Code Contracts library which is coming out of Microsoft R&D labs, you need to check this pretty cool little library out. As of Vs2010/.Net 4.0 this library will be making the jump out of the R&D labs. This is the first in a series where we will walk though various parts of the contracts library.

Var Wars - Abuse of the CSharp var

Mon, 08 Jun 2009 15:04:49 GMT

CSharp 3.0 introduced the var keyword for declaring variables without having to explicitly specify the type. This was done for using anonymous types returned from LINQ queries. Now, I am seeing many developers use it all over their code and think its a good thing.

Developing Component-Driven Applications powered by IoC

Wed, 03 Jun 2009 20:05:36 GMT

This article continues talk on the topic of Component-Driven Development with IoC Containers. We'll expand on the topic of the actual development process of new applications and migrating existing legacy applications...

Core: An Aspect Oriented Business Objects Framework

Tue, 02 Jun 2009 13:35:54 GMT

Learn about aspect-oriented design patterns and how they can be used to quickly add common functionality to your business objects. Josh Heyse explains how Aspect-Oriented Programming allows for the separation of true business logic and the code written allowing interaction with user interfaces. The Core framework is a generation model that dynamically adds common services, such as logging, auditing, persistence, and security to business objects.

How to Create a Custom Performance Counter

Tue, 02 Jun 2009 16:00:03 GMT

Taking a look at how to create custom performance counters for usage in your application Part of the core .net framework allows you to create code which can hook into the underlying performance counters which the windows OS has. We will show how you can easily create hooks to take advantage of these counters.

Inversion of Control - IoC - Wiki

Mon, 01 Jun 2009 19:05:37 GMT

Inversion of Control (IoC) is an approach in software development that favors removing sealed dependencies between classes in order to make code more simple and flexible. We push control of dependency creation outside of the class, while making this dependency explicit. Usage of Inversion of Control generally allows to create applications that are more flexible, unit-testable, simple and maintainable in the long run.

LINQ Expression Trees and the Specification Pattern

Mon, 01 Jun 2009 00:55:37 GMT

A very interesting article about DDD. David discusses implementing the Specification Pattern via LINQ's Expression type...

Component-Driven Development and IoC Containers

Sun, 31 May 2009 19:55:31 GMT

Let's try to reiterate and summarize some ideas about the Component Driven Development, IoC containers and evolving enterprise applications in general.