Recently I have been introduced to a new modeling tool called Enterprise Architect.
It is truly a great product for a great price.
It has full support for UML 2.1.
They have a robust and easy solution for distributed teams that have a need to access design artifacts.
Artifact Store
Local File or Shared Network Store
As with any modeling software you can store a file containing your models.
DBMS
You can easily configure SQL server to be your backend store, which allows a multi-user access to your modeling projects.
Source Control
Either you can use a DBMS in conjuction with a Version Control Product (Shared Model)
or you
use a local file based solution with a Version Control.
The major source control providers are supported out of the box, and you can add support for work item tracking in tfs with an optional plugin.
The price is very reasonable at $250 for an enterprise seat.
Compared with $5000 for Rational Software Architect, which is comparable to Power Designer and ErWin.
If you want to do some serious modeling without having to sacrifice your yearly budget. I would suggest getting a few copies of enterprise architect for your team.
Slim Timer is great web based task tracker and timer.
It also has some great reporting built in.
Check it out.
Every place of employment has their favorite patterns and this one is no different.
Lazy Loading is a common theme amongst many of of the entities.
Basically take a property and in the get, check for null. If its null then load using a manager or something. If its not null then the list has been loaded.
It really only works for lists.
I think if you are going to do a SOA app, you should stick with the philosophy of plain old clr objects (poco) and just leave your accessors alone. Put the loading logic in a manager and load explicitly. It can become a hidden performance issue, when lists are just loading when you look at them.
The method I am talking about above is called Lazy Initialization (Fowler)
There are also several other types of Lazy Loading Fowler talks about including: Virtual Proxy, Value Holder, and Using Ghosts
The Ghost pattern looks as though it may overcome the hidden performance problem by creating a lazy loading supertype that wraps the load status. So you can tell if the list is of type “ghost”, “loading” or “loaded” A ghost would mean that the property should be lazy loaded when the oppurtunity arose. The problem I have with this, is the extra complexity of adding more layers.
In the end for me, it just seems easier to develop a robust manager architecture where explicit loads are easy and intuitive.
Fowler Martin. Patterns of Enterprise Architecture. 2003.
Before you go out and drop some extension methods on System.Object, read the this addendum on framework design guidelines for C# 3.0.
So the f1webchallenge is happening tomorrow morning.
The question is how does a .net developer who traditionally works on large projects transition to a development project that happens in just 24 hours.
One question is how do we handle our Data Layer.
Since it is Mysql, we can just use MySql.Data and get basic functionality, but for something that is going to need to be done very fast will that cut it?
There is also the Enterprise Application Blocks.
Here is how to build it into the Enterprise Application Blocks.
Adding MySQL.Data to Enterprise Application Blocks
There is also Enterprise Library Contrib
Something similar to the building it in, except you just run an installer.
Then there is the OR/M frameworks.
NHibernate
This just seems to big and bulky for a quick and dirty project.
I have used this in a larger application and things that should be simple are difficuly and things that should be hard are easy(sometimes).
Subsonic
I am going to do some more experimenting with Subsonic.
I have used it before and hooked it up as a post compile task, this had the disadvantage of invalidating code whenever the database was updated.
Early in a project this can be frequent.
This time around I have a batch file, and I am going to just generate the Table classes when something changes.
This should work pretty slick and should save a lot of time writing CRUD stuff.
I will post the results after the competition to see what solution wins.
Just heard the announcement.
XNA games on the zune by the end of the year.
I am so excited.
Recently a service pack was released for the 2.0 version of the .NET Framework.
As usual there was a laundry list of fixes, most of which were difficult to figure if they fixed or improved your production code.
ADO.NET performance was improved considerably especially when using the SqlDataReader
Original Article
I think the single most important principle to writing readable code(imho)is SRP(Single Responsibility Principle)
In a nutshell
It is just making your classes and methods do one thing and that’s it.
Or at the very least name your methods accordingly if they do a couple of things.
An MS Example of breaking the SRP Rule.
bool Int32.TryParse(string s, out int result)
The benefits are numerous.
It is easy for other programmers to read your code.
Your methods get much shorter.
Refactoring becomes obvious when code starts to do more than one thing.
Unit Testing is easier and clearer.
Even though topics on Inversion of Control have been done to death.
I want to revisit the subject to talk about the use of interfaces in inversion of control.
I think Interfaces should be used to isolate all dependencies on the outside world, not just databases.
When doing something with WCF. The client side service calls should also be using IOC so they can be isolated and the client side as a unit can be tested.
