Design Build Release

I have moved.......

2010-01-17T10:06:00.000-08:00

Finally got around to setting up a "proper" blog on my own hosting. The main reason was to be able to utilise some of the code highlighting tools.

My blog can now be found at www.iainjmitchell.com/blog

Parallel Extensions in .NET Part 2

2009-10-26T01:15:00.000-07:00

In the last post I covered the Co-ordination Data Structures in .NET 4.00, so now I will examine the Task Parallel Library and Parallel LINQ (PLINQ).

As I mentioned in the last post, Mike Taulty explained that the thought behind the Parallel Extensions is to abstract the multi-processor jobs away from the concept of threads. The Task Parallel Library contains objects that allow you to achieve this.

At the heart of this is the Task object which represents a unit of work to be carried out. There is a factory version (as shown below) and a standard object version of this class.

Task myTask = Task.Factory.StartNew(() =>

{

//code to be carried out

});

myTask.Wait(); //wait for task to complete

Which ever method you use to construct the object it is passed a predicate which contains the work to be carried out. Tasks are atomic operations that can be carried out on any of the processors in the PC. The Wait() command is only applicable if you need to wait for the result of the Task

An interesting feature of Tasks is that a Task can start off other Tasks within them.

Task parentTask = Task.Factory.StartNew(() =>

{

Task childTask = Task.Factory.StartNew(() =>

{

//code to be carried out

});

//other code to be carried out

});

These child classes are automatically linked to the Parent class, so that if you call Wait() on the parent class then this will wait for any child Tasks to finish. This default behavior can be turned off (if required) in an extra parameter passed into the constructor.

Another intriguing feature about these Tasks is that when an exception occurs within the main Task or one of it's children, the exception thrown is a AggregateException. This exception contains a new property called InnerExceptions that contains any exceptions that are thrown by the children. So, if three child task are spawned and all of these throw an exception you can view all of these in this AggregateException. Nice.

Mike also introduced the Parallel static class which provides an alternative way of spawning multiple Actions. It has handy methods such as Parallel.ForEach that allows a number of actions to be thrown a number of times. I won't go into too much detail about this one, but if you look on the recently published MSDN for .NET 4.00 there are plenty of examples of it's use.

Finally, Mike introduced use to Parallel LINQ, otherwise known as PLINQ! This is a command that can be used on LINQ queries to make them execute across multiple processors. It's purpose is to make LINQ queries on any large data sources more efficient.

PLINQ is very easy to use, all you need to do is utilise the AsParallel() at the appropriate place in the LINQ query. For example:

var results = myData.AsParallel().Where(x => x.Name == "World").Count();

It's that easy!

That concludes my whirlwind tour of the Parallel Extensions in .NET 4.00. There are plenty of other resources on the MSDN and various microsoft blogs on Parallel Extensions. Here are a few:

Introduction to PLINQ
Microsoft Parallel Computing Center
Microsoft Parallel Programming Team Blog
Mike Taulty's Blog

Parallel Extensions in .NET 4.00 Part 1

2009-10-22T00:35:00.001-07:00

Last night I attended an NxtGen User Group in Manchester at which Microsoft guru Mike Taulty was giving an introduction to the new parallel programming components of the .NET framework.

Whether we like it or not we, as developers, are going to have to adapt to using techniques that will run code on separate processors. The new chips from Intel and AMD are no longer continuing to increasing in Ghz, they are just containing more processors. So, we need to be able to utilise this power.

The good news is that the .NET CLR and certain components, such as WCF and WF, already spread their workload across multiple processors. But the bad news is that our own programs do not.

So, how would you currently handle this? The answer is by using a Threads or a ThreadPool. But as Mike demonstrated this is quite long winded and makes the code quite difficult to read.

The idea behind the Parallel Extensions in .NET 4.00 is to abstract the concept of the work that can be carried out on multiple processors away from the underlying concept of threads. They have split the components up into the following three categories:

Co-ordination Data Structures.
Task Parallel Library
Parallel LINQ (PLINQ)

Lets start with the Co-ordination Data Structures. This category contains all the replacement data structures that are required to support parallel programming. If you have ever performed any thread safe work that involves a collection, you will know that none of the collections in .NET are thread safe. The only solution is to lock the entire collection when carrying out any work. Which frankly is a bit rubbish.

The co-ordination data structures contain a selection of Concurrent Collections to get around this issue. These include ConcurrentLinkedList and ConcurrentQueue. It also includes some advanced Co-ordination helpers that include a Barrier (blocks work until a x number of threads reach) and a CountdownEvent (a concurrent countdown that can be signalled from multiple threads).

The last of the co-ordination data structures is the Data Synchronization classes. The main one of interest is the Lazy class. Great name, but what does it do? It allows you to create a thread safe Singleton class. For example, say we have a singleton class called MyClass which has a method called MyMethod(). Initialisation of the singleton can be complex as we may have several threads entering the initialisation code. The solution is to use the Lazy class to wrap the class like so:

Lazy myInstance = new Lazy<MyClass>();

myInstance.Value.MyMethod();

This ensures that ONLY one instance of this class will exist.

In the next part I will cover the Task Parallel Library.

Creating comma separated strings with LINQ

2009-10-20T02:36:00.001-07:00

Here is a really quick LINQ based solution to the conversion of a collection of strings into a comma separated string:

//Prepare list

List myList = new List();

myList.Add("aString");

myList.Add("anotherstring");

//Get comma separated string

var stringBuilder = myList.Aggregate(new StringBuilder(), (builder, stringValue) =>

builder.AppendFormat((builder.Length == 0) ? "{0}" : ", {0}", stringValue));

string commaString = stringBuilder.ToString();

WCF Tracing with Activities

2009-09-28T00:10:00.000-07:00

One of the nice features of Windows Communication Foundation (WCF) is that it can generate an excess of trace information that can help us identify issues with our services. All you need to do is turn the tracing on through the app.config like so....

name="System.ServiceModel"

switchValue="Information">

name="traceListener"

type="System.Diagnostics.XmlWriterTraceListener"

initializeData= "c:\log\Traces.svclog" />

Microsoft even provide a handy tool called Service Trace Viewer Tool (SvcTraceViewer.exe) that can be used to view the trace information that WCF produces.

However, if you have ever looked at one of these traces you will have noticed that it can be difficult to sieve through and find the service call(s) that you are interested in. It becomes especially difficult if the service calls other services. Wading through all this tracing information is time consuming and it can be very frustrating.

Fortunately WCF provides a mechanism called Activities that allow us to correlate related trace information.

Where these Activities start and stop are defined by the developer in code. They can also be propagated across service boundaries and can also be linked together with other related activities.

So, what do you need to do in order to use Activities in your tracing? They are quite simple to use, all you need to do is assign an activity id to the correlation manager. This is a GUID value and is assigned as follows:

Trace.CorrelationManager.ActivityId = Guid.NewGuid();

Now, all the trace messages that are fired after this will be included in this Activity. However, in order for this to appear in the trace log we need to add ActivityTracing to the switchValue of the diagnostics section of the app.config.

name="System.ServiceModel"

switchValue="Information ActivityTracing"

propagateActivity="true">

name="traceListener"

type="System.Diagnostics.XmlWriterTraceListener"

initializeData= "c:\log\Traces.svclog" />

Also, if we want the ActivityId to be passed from one service to another, we can set the propagateActivity attribute to True. This is useful if we are starting the activity in one service operations that is then calling other services operations to achieve it's goals. With propagateActivity set to true, all of the trace information from these services for this particular call would be grouped together.

UML Aggregation vs Composition

2009-09-16T11:16:00.000-07:00

A colleague asked me a few weeks ago for some advice about their UML class diagram. One of the issues they were having was deciding on whether the link between two of the classes should have a "filled-in" or "non-filled-in" diamond.

You have probably already guessed that he was really asking about whether the two classes were linked by Aggregation ("non-filled-in") or Composition ("filled-in"). From my experience, this is a very confusing area of UML for some developers. I have reviewed may class diagrams where the developer seems to have just liked the look of one of the diamonds and just used it on all of their associations!

So, where should these notations be used? If you search on the internet you'll find a plethora of explanations, but I thought it might be useful to try and add a simplified explanation.

First off, this is the difficult part for developers, Aggregation and Composition are nothing to do with code. Both Aggregation and Composition are effectively talking about is one class contains another class. So, many explanations suggest it's Aggregation if it's public property and composition if it's a private field. But unfortunately it doesn't work like that.

The decision on whether a relationship is a Aggregate or Composite is based on how the classes are related in the real world. Take a classic UML example of a Car class. Your car class may have a engine class, a collection of wheel classes and a fluffy dice class. So, which of these are aggregates and which are composites?

Lets start with the engine class. This is quite a vital part of the car, you couldn't imagine a car without an engine. Likewise, the wheels are quite important too. In fact you could say that the car is composed of (among other things) an engine and wheels. So, these relationships are examples of Composition.

The remaining fluffy dice class is a bit of a looser relationship. A cars function does not depend on the tacky fluffy dice attached to the mirror. The car may not even have fluffy dice. So, this demonstrates quite nicely a Aggregation relationship.

So, our resulting class diagram looks something like this...

Oracle vs .NET int

2009-05-11T06:11:00.000-07:00

One of the problems of using .NET with Oracle is the type conversion of integers through the ODAC component. Basically, the problem comes about because the ODAC component has no idea which .NET type to use when returning a value in a NUMBER field.... so it panics and just tends to return everything as a double (remember that the NUMBER field can hold decimal values!).

Oracle have also provided the INTEGER data type, which is really just a short-cut to get a NUMBER(32) field. The best solution I can find to this is to define any columns that are being mapped to a .NET int as NUMBER(9, 0). This will always ensure that the field will hold data that is compatible with being held in a .NET int.

Devweek Day Two

2009-03-25T21:00:00.000-07:00

Session 1 - Building applications in the ‘cloud’ with Azure services.

Started the day back with Christian Weyer for another of his amusing style of talks. This time he was introducing how Azure can be used to build applications in the ‘cloud’. The overall impression that I am getting of Azure is that it is a work in-progress. Christian demonstrated this by showing a technology uptake diagram, which well and truly placed ‘cloud’ computing in the emerging technologies section.

Azure is organised into two types of service, web and worker services. The idea is that the services can be up scaled so that the capacity of the application can be increased. For example, if you have a particularly popular web service that starts getting hit by thousands or millions of users you can log into Azure and increase the number of service instances to cover this demand.

Underlying the two core service types is the service bus. This is basically an enterprise service bus in the ‘cloud’. It allows the management and routing of service interactions with services held within the cloud and locally.

Christian also briefly showed the Azure workflow services. These will allow processes or interactions between services to be mapped out visually. Azure workflow's are not based on standard Windows Workflow (WF). They only have a relatively small sub-set of activities that are very ‘cloud’ specific (e.g. connect to cloud service). Although WF seems to be a major part of Microsoft's ‘cloud’ master-plan, they are still far from stable.

Session 2 - The Patterns Dartboard.

For some light entertainment prior to lunch I decided to attend this talk on design patterns. The premise of this talk was that a dart was to be thrown at a ‘dartboard’ of design patterns. Whichever pattern the dart hit one of the presenters, Kevin Jones and Andy Clymery, would present to the group in no more than 15 minutes.

During the next hour and a half they covered the Decorator, Factory, Active Record, State and Mode View Controller (MVC) design patterns. Of these I had particular interest in the Active Record presentation. Actually a first I had no idea what this design pattern was! Then as the presentation moved onwards I realised this is another name for what used to be my favorite design pattern, the Persistence pattern.

I have to say, I very rarely use Active Record (AKA Persistence) anymore, Though it is quite well suited to a small reliable system. I don’t know a great deal about Ruby on Rails but apparently this is the design pattern that it utilises.

For those not familiar with Active Record is that the class should contain the business logic and the code necessary to persist the object in the data store (usually some kind of database). Their interpretation of Active Record suggested that all ‘read’ actions should be static methods and all ‘write’ actions should be instance methods. The example class below demonstrates this:

public class MyClass
{
private int Id;

public static MyClass GetMyClass(int classId)
{
//database select code and return new object with data...  }

public void Save()
{
//if object does not have ID then INSERT to database else UPDATE...  } }

I must admit that in my my years of employing this design pattern it never occurred to me to implement the loading functions as static members.

Session 3 - WCF Security Architecture and Best Practice.

This was one of the ‘must-see’ sessions of the week for me, particularly due to recent issues that I have encountered with security within my WCF applications. Like many features within WCF this can be a confusing area as there is SO much that is configurable.

Dominick Baier ran this session which went into incredible detail about the security options that are available within WCF. I can’t say that I managed to find an exact solution to my particular problem, but I found it a great grounding in the elements of WCF security (it’s all about the Binding!). Plus, I now have his email address - beware Dominick!

As I’m still taking in this wealth of knowledge it is difficult for me to expand any further at the moment.

Session 4 - Visual Studio 2008 IDE Tricks and Tips.

Can I first say that I attended this session purely as my brain couldn't take any more heavy talks on the second day. The WCF security session well and truly finished me off!

Though I have to say that I will be using many of the short-cuts that were introduced in this session. Here is a website that summarises the standard shortcuts in Visual Studio.

Devweek Day One

2009-03-24T20:00:00.000-07:00

Here is a quick summary of the sessions that I attended on the first day of DevWeek in London.

Session 1 - Keynote: Cloud computing - a new era of software development.

At the opening of this session Aaron Skonnard asked who knew anything about Cloud computing. I didn’t raise my hand as I still feel that I don’t know that much, though in retrospect I could have done as this session covered pretty much what I already knew!

Over the hour and a half he covered the different types of “clouds” in distributed computing, starting from basic network design then moving on to Software as a service providers an finally the new online cloud computing providers such as Google, Amazon and briefly mentioning Microsoft’s Azure.

Session 2 - A Beginners guide to Windows Workflow (WF).

I’ve had a few attempts at using WF but thought I’d attend this session to see if I’d missed anything. It turns out I had!

Richard Blewett ran an interesting session with plenty of code samples taking the audience through the basic WF components. For those who have never seen WF it provides a graphical tool to arrange “activities” which interact with your underlying code. It allows you to design the business process through a diagram rather than inside lines of code.

One of the nice features of WF is that you can attach workflow services to the runtime that the workflow’s can then interact with (don’t confuse these with WCF or Web services). If these services are defined from interfaces of abstract classes then it allows a dependency injection mechanism into the workflow.

Richard showed an example where a custom activity talking to a workflow service which showed a textual output. The custom activity retrieved an abstract class called MyOutput, it had one abstract method called WriteOutput which required a message as a parameter. He had written two child classes of the abstract class, one of which wrote the message to the Console and one which wrote the message to a MessageBox.Show(). He then demonstrated that switching between adding each of these to the workflow runtime services resulted in the change of behavior when the workflow containing the custom activity was run.

He also spent some time talking about how custom activities can utilise the WorkflowQueue service to put items that are needed for interaction outside the workflow.

Session 3 - IronRuby.

This session was one of my high points of the day. I've heard much said about Ruby on Rails and was intrigued by Microsoft's .NET compatible interpretation.

Tim Ewald went through the main language differences between IronRuby and the CLR languages. One of the interesting examples was this:

1.upto(10) { |n| put n}

Which is the equivilant of this in C#....

for(int i; i <- 10; i++) { Console.WriteLine(i); } .. pretty good stuff!

Session 4 - WCF Tips and Tricks.

Christian Weyer took this session which looked at how WCF should be used in the real world. His ideas seem to match many conclusions that we have drawn, such as self-hosting is the way to go at the moment and providing some mechanism for locally initialising services is a good idea (has he been spying on our system? :))

One interesting point that he raised was that you should check the state of the service connection before attempting to close it. I certainly hadn't thought about this in our client code.

WCF Exceptions and Faults

2009-03-05T03:51:00.000-08:00

In Windows Communication Foundation (WCF) exceptions thrown from services have to be converted into Faults - which are basically cross domain friendly exceptions. Custom faults can be created and are just declared using the [DataContract] attribute. The example below shows the declaration of a simple Fault.

[DataContract]
    public class MyFault
    {
        [DataMember]
        public string Message { get; set; }      

        public PasswordFault()
        {
        }

        public PasswordFault(string message)
        {
            this.Message = message;
        }
    }

To generate a WCF fault you have to use the FaultException class. The example below shows how we could raise the fault declared in the previous example.

public class myService: IMyContract
{
 public void MyMethod()
 {
    try
    {
       ......
    {
    catch (myException exc)
    {
      MyFault = new MyFault(exc.Message);
      throw new FaultException(MyFault, "Failed to run MyMethod");
    }
 }
}

One other important part of setting up faults in WCF is that the OperationalContract of the method raising the fault needs to define the the FaultContracts that the method can raise. For example we might define the service contract of our service to be as follows:

[ServiceContract]
public interface IMyContract
{
 [OperationContract]
 [FaultContract(typeof(AuthenticationFault))]
  void MyMethod();
}

The FaultContract attribute is telling WCF which faults can be expected. If a fault is thrown that is not defined here, the client will just get an ambiguous FaultException raised and be unable to access the extra data defined in the Fault.

Alternative Fault Handling Techniques

Recently, during the development of quite a large SOA based system I noticed that Faults that are raised by sub-services were not being raised correctly through the next service. The only way to ensure that these faults were received by the client was to recapture the fault (as a FaultException() ) and re throw them!

After a bit of investigation and a very helpful reply to a post on the MSDN WCF forum I was pointed in the direction of this example of using the IErrorHandler interface to add custom error handlers to the individual channel dispatcher. I'm not going to go into any great amount of detail about this, but I strongly recommend reading the article. It gives you a much more elegant way of handling exception to fault conversions in WCF.

Safari 4

2009-03-04T01:57:00.000-08:00

A beta of Safari 4 for Mac and PC was released last week, go here for download.
It features some rather nice eye candy - such as a "cover flow" browsing history and a rather nice favorite site window (see screen shots above).

I'm sure many web developers will be shuddering at the thought of yet another browser to support, but it does bring with it some new web technologies (such as CSS 3 and HTML 5). It also provides some rather nice looking developer tools, see here for full feature list.

I tried using Safari 4 for a couple of days on my work PC. It seemed to be noticeably faster than other browsers, though it did seem to hang a bit when adding new tabs - this might be because it was set to always start new tabs on the favorite site window. I think if the hanging issues could be resolved it could give Firefox some competition.

Oracle XmlType and ODAC .NET provider

2009-02-25T08:23:00.000-08:00

I have been having some issues today with a method that inserted Xml into an XmlType field in an Oracle database. It had been working fine, but recently the Xml had grew in size considerably. I was now getting the following Oracle error returned from the ODAC component:

ORA-01461: can bind a LONG value only for insert into a LONG column

The Insert Query I was running looked a bit like this....

INSERT INTO myTable

(anId, myXmlField)

VALUES

(:anId, :myXmlField);

When I ran the query I had two parameters, the second (:myXmlField) was an Xml string. It was this that caused the issue. Thanks to this post by Stuart Campbell I found out that in order to pass a long string value to an XmlType field you must:

1) Set the parameter type of the xml parameter (:myXmlField) to Clob;

2) Use the XmlType() call in the query:

INSERT INTO myTable

(anId, myXmlField)

VALUES

(:anId, XmlType(:myXmlField));

This did resolve the issue, but in the end I ended up changing the XmlType field into a Clob! This is because 1)I didn't need to xPath the Xml in the database and 2) I couldn't use XmlType implementations in our SqlServer data access layer as we have to support earlier versions of this database.

For those in the North West.....

2009-02-24T01:54:00.000-08:00

There is a free MSDN event on at the Lowry in Manchester on Thurday afternoon (26-Feb-2009).
The event is covering WPF and Silverlight 2.

See here for further details and registration.

Custom authentication

2009-02-23T15:37:00.000-08:00

Occasionally you may have to develop a system that, rather then relying on an existing security system (e.g. active directory, novell), requires you to write a custom authentication system.

Usually, in such systems the user data and passwords are stored in a table in the database. These records can then be queried to determine whether the user requesting access has the correct password.

Okay, this is simple enough... but storing a users password in a table is not particularly great. A hacker or other unauthorised user might get access to the table and thus be able to log onto our system as anyone they choose!

It is better practice to encrypt the password before storing it in the database. The software will have to retrieve and decrypt this value before the users password entry can be validated.

Even if encryption is used, the account could still be open to attack as Users might choose an obvious password. Fortunately, extra precautions can be added to the security system to help further protect against unauthorised access. These are:

1) Adding rules for password format - Regular expressions can be used to ensure when a user sets their password it adheres to certain standards (e.g. contains 1+ numbers, is a certain length).

2) Password attempts - Implement code to lock the account if the password is entered incorrectly over a certain number of times. To save on hassle for the system administrators you might want to consider just locking the account for a set period (e.g. 2 hours).

3) Encrypt with Salt values - A salt value is a value that is added to password prior to encryption to make the encryption more difficult to crack for hackers using dictionary attacks. I would strongly recommend using salt values if you are using encryption.

In .NET salt values can be generated by using a class such as RNGCryptoServiceProvider. The code below shows a static method I use to generate salt values.

/// 
/// Generate a random salt value
/// 
/// 
public static string GenerateSalt()
{
  RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
  byte[] randomNumber = new byte[16];

  rng.GetBytes(randomNumber);
  return Convert.ToBase64String(randomNumber);
}

The encryption algorithms in .NET (such as the preferred RijndaelManaged class) allow you to set the salt value when encrypting and decrypting values.

It is important to remember that when you use a salt value that this will also need to be stored somewhere, so that it can be retrieved by the code when it needs to decrypt. Salt values should NEVER be stored in code as a hacker could use a disassembler on the assembly and discover the value.

I always dynamically create a new salt value every time a users password is changed. This value
is then stored in a separate table in the database, linked to the record by the user table primary key. This can then be easily retrieved when the code needs to decrypt the data.

I hope I've managed to cover the main points of creating a custom authentication system. It'll will be interesting to see what the next generation of security systems in WCF 4.0 and Azure will bring. I'm hoping that there will be considerable improvements so that developers will not have to keep reinventing the wheel with their own authentication methods. I am attending DevWeek next month in London, so I'll blog/twitter my discoveries....

Stored procedure maintenance

2009-01-27T02:07:00.000-08:00

One of the nice features of Oracle stored procedures, functions and packages is that you can create or recreate the database side code in the same statement. The advantage of this is that during upgrades/patches you can run ALL database code scripts again, which ensures nothing is missed - and also that the changes you have made haven't caused breaking changes in another procedure!

For example, the following will create or replace the following security package header..

CREATE OR REPLACE PACKAGE PKG_SECURITY
AUTHID DEFINER
AS
/*  ------------------------------------------------------
    Adds authentication for specified user to system    
    ------------------------------------------------------ */
PROCEDURE proc_AddUserAuthentication(
  userId                IN USERSECURITY.USER_FK%TYPE,
  encryptedPassword     IN USERSECURITY.PASSWORD%TYPE,
  saltValue             IN USERSALT.SALT%TYPE,
  auditUserId           IN USERSECURITY.AUDITUSERID%TYPE);
END;
/

My recent digging around has revealed that you can also mimic this CREATE or REPLACE functionality in MySQL and Sql Server.

In MySQL you can call the DROP PROCEDURE IF EXISTS method....

DROP PROCEDURE IF EXISTS premierenvoy.proc_AddUserAuthentication;
CREATE
DEFINER = CURRENT_USER
PROCEDURE proc_AddUserAuthentication(
............

...and in Sql Server you can use the OBJECT_ID function and check whether the returning value is not null to determine whether to drop the procedure.

IF OBJECT_ID('proc_AddUserAuthentication') IS NOT NULL
DROP PROCEDURE proc_AddUserAuthentication;
GO
CREATE PROCEDURE proc_AddUserAuthentication(
............

Using Data Grids in WPF

2009-01-08T00:26:00.000-08:00

One of the biggest omissions from the .NET 3.5. WPF control library is a Data Grid. There are many 3rd party implementations for sale of free (just do a Google search on WPF and DataGrid). However, it is also possible to use the standard Windows forms DataGrid within your WPF form.

This excellent article by Rahul Saxen explains how this can be achieved.

MySQL Triggers

2008-11-20T07:53:00.000-08:00

My recent 'baptism of fire' with MySQL triggers has revealed a couple of differences with their cousins in the SQL Server and Oracle domain.

1) You need seperate triggers for UPDATE, INSERT and DELETE. Oracle and SQL Server will let you combine these into one trigger.

2) You cannot create triggers dynamically using a Procedure. The Execute command in the stored procedures works fine when creating a table, but try creating a Trigger. The parser throws an error stating that you can not run these types of commands.

The real problem for me has been 2). I often rely on writing procedures to apply auditing to a table (composed of audit table and trigger to insert the data from the main table into the audit table).

Creating copies of tables in Oracle, SqlServer and MySQL

2008-11-06T06:27:00.000-08:00

As the sub-title of my blog suggests, I am from an Oracle background. But I also have dealings with SQL Server and MySQL databases. In fact the latest project I'm working on is going to have to work with all three databases!

One issue I have encountered recently is how to create copies of tables in SQL Server and MySQL. In Oracle you would use the AS keyword in the CREATE table statement and select from the table that is being copied. For example:

CREATE TABLE myCopyTable AS
SELECT * FROM myOriginalTable;

You can add a WHERE clause to restrict the records that are included in the copy. Making this WHERE clause into a condition that is not achievable (such as WHERE 1 =2) will result in a copy of the table without the data.
Note: This copy does not include any indexes/constraints on the original table.

In MySQL it is similar but you do not need the AS keyword. For example:

CREATE TABLE myCopyTable
SELECT * FROM myOriginalTable;

Alternatively you can actually create an exact copy including all constraints and indexes. This is achieved by using the LIKE keyword.

CREATE TABLE myCopyTable
LIKE myOriginalTable;

Note: This won't take the data across, you would have to insert that afterwards
(e.g. INSERT INTO myCopyTable SELECT * FROM myOriginalTable;)

Finally, SQL Server... which wins the prize for the strangest implementation. You actually use a SELECT command to create your new table :o

SELECT *
INTO myCopyTable
FROM myOriginalTable;

I really don't like the way this is implemented as there is no mention of a table being created in the SQL statement. Even though this is what the user is trying to achieve.
Anyhow, no point complaining at least they provided a way of copying a table :)

Auto numbering fields in Oracle

2008-10-31T07:48:00.000-07:00

Auto numbering fields often come up in debates between fans of Oracle and SqlServer. The SqlServer devotee will argue that their database has the advantage as it provides easy to use auto numbering fields. The Oracle believers come-back will undoubtedly be... "ah but you can use Triggers".

So how do you? Luckily, I've just been implimenting this very thing in Oracle, so I thought I'd share with you my solution.

First off, let me define a table that the solution will be based upon....

CREATE TABLE TestTable
( TestTable_PK NUMBER(10) NOT NULL PRIMARY KEY,
AValue VARCHAR2(10)

The first column (TestTable_PK) is the one which we want to populate with an auto numbering value.

# Applying auto-numbering:

The auto-numbering solution is made up of two components:

The Sequence - to provide the auto numbering value.
The Trigger - to add the auto numbering value to the row.

So, let us start by defining the Sequence....

CREATE SEQUENCE TestTable_SEQ
MINVALUE 0
MAXVALUE 999999999999999999999999999
START WITH 1
INCREMENT BY 1;

...and then we can define our auto numbering Trigger.

CREATE TRIGGER TestTable_TRG
BEFORE INSERT ON TestTable
FOR EACH ROW
BEGIN
SELECT TestTable_SEQ.nextval INTO :new.TestTable_PK FROM dual;
END;

The Trigger has to occur before the insert otherwise the Primary Key unique constraint will throw an error. It also has to fire for each row because if we are inserting multiple records we want a different sequence value for each. The :new variable in the trigger references the row contents that is inserted to the table after the Trigger has fired.

# Returning the auto-numbering value:

Okay, so now we have out auto numbering working, how can we insert data and return the auto-generated number? This can be achieved by using the RETURNING keyword on the INSERT statement. For example:

INSERT INTO TestTable
(aValue)
VALUES
('Some Data')
RETURNING TestTable_PK INTO :value;

The :value is a variable that can be queried in the client to get the returned field.

# Generic Solution:

In the code block below I have included the code to PL/SQL package that I have written to automatically add auto-numbering to a specified table. I do make an assumption in my code that the column that is being used as a auto numbering field is called _PK. You could write to query the data dictionary views to return the actual Primary Key, but this could cause problems if the Primary Key includes more than one field.

Hope you find it useful.

CREATE OR REPLACE PACKAGE PKG_Utilities
AUTHID DEFINER
AS
/*  ------------------------------------------------------
Add Auto numbering to the Primary Key of the table.
------------------------------------------------------ */
PROCEDURE proc_AddAutoNumbering(
tableName IN VARCHAR2);
END;
/

CREATE OR REPLACE PACKAGE BODY PKG_Utilities
AS
/* ***********************************************************************
FORWARD DECLARATION OF PRIVATE METHODS
*********************************************************************** */
FUNCTION func_AddAutoNumberingSequence(
tableName IN VARCHAR2) RETURN VARCHAR2;
PROCEDURE proc_AddAutoNumberingTrigger(
tableName IN VARCHAR2,
sequenceName IN VARCHAR2);
FUNCTION func_ObjectExists(
/*  Does the object exist in the current schema? */
objectName IN VARCHAR2,
objectType IN VARCHAR2)
RETURN BOOLEAN;
FUNCTION func_GetSafeIdentifier(
/*  Returns an identifier under 26 characters in length
that can be concatenated with a prefix such as _TRG and
still be under the 30 character limit for Oracle object names */
objectName IN VARCHAR2)
RETURN VARCHAR2;
/* ***********************************************************************
PUBLIC METHODS
*********************************************************************** */
PROCEDURE proc_AddAutoNumbering(
tableName IN VARCHAR2)
IS
sequenceName VARCHAR2(200);
BEGIN
sequenceName:= func_AddAutoNumberingSequence(tableName);
proc_AddAutoNumberingTrigger(tableName, sequenceName);
END;
/* ***********************************************************************
PRIVATE METHODS
*********************************************************************** */
FUNCTION func_AddAutoNumberingSequence(
tableName IN VARCHAR2)
RETURN VARCHAR2
IS
execute_sql  VARCHAR2(1000);
sequenceName VARCHAR2(30);
BEGIN
sequenceName:= func_GetSafeIdentifier(tableName) || '_SEQ';
IF (NOT(func_ObjectExists(sequenceName, 'SEQUENCE'))) THEN
execute_sql:= 'CREATE SEQUENCE PremierEnvoy.' || sequenceName || chr(10) ||
              'MINVALUE 0 ' || chr(10) ||
              'MAXVALUE 999999999999999999999999999' || chr(10) ||
              'START WITH 1' || chr(10) ||
              'INCREMENT BY 1';
EXECUTE IMMEDIATE execute_sql;
END IF;
RETURN sequencename;
EXCEPTION
WHEN others THEN
raise_application_error(-20001, 'Failed to Add Sequence - ' || execute_sql);
END;

PROCEDURE proc_AddAutoNumberingTrigger(
tableName IN VARCHAR2,
sequenceName IN VARCHAR2)
IS
triggerName VARCHAR2(30):= func_GetSafeIdentifier(tableName) || '_TRG';
execute_sql VARCHAR2(2000):=
'CREATE TRIGGER PremierEnvoy.' || triggerName || chr(10) ||
'BEFORE INSERT ON PremierEnvoy.' || tableName || chr(10) ||
'FOR EACH ROW ' || chr(10) ||
'BEGIN ' || chr(10) ||
'  SELECT ' || sequenceName || '.nextval' || chr(10) ||
'  INTO :new.' || tableName || '_PK FROM dual;' ||  chr(10) ||
'END;';
BEGIN
IF (NOT(func_ObjectExists(triggerName, 'TRIGGER'))) THEN
EXECUTE IMMEDIATE execute_sql;
END IF;
END;

FUNCTION func_ObjectExists(
objectName IN VARCHAR2,
objectType IN VARCHAR2)
RETURN BOOLEAN IS
objectCount NUMBER;
BEGIN
SELECT count(object_name)
INTO objectCount
FROM user_objects
WHERE UPPER(object_name) = UPPER(objectName)
 AND UPPER(object_type) = UPPER(objectType);
RETURN (objectCount > 0);
END;

FUNCTION func_GetSafeIdentifier(
   objectName IN VARCHAR2)
 RETURN VARCHAR2
 IS 
 BEGIN
   IF (LENGTH(objectName) < 25) THEN
     RETURN objectName;
   ELSE
     RETURN SUBSTR(objectName, 0, 25);
   END IF;
 END;

Deep Copies in .NET

2008-10-23T08:28:00.000-07:00

A problem that I often have when writing WCF services is that WCF complains when you try to send an Object that has been cast to an ancestor over the wire (as a DataContract). WCF responds by getting confused as to what type of object it is returning.

The only solutions is to create a new instance of the parent class and copy all the fields/properties from the child. This is effectively making a Deep Copy of the object... so it got me thinking about how I could impliment a Deep Copying function in .NET.

My Solution has been implimented as an Exension Method as I want it to be called on a class, but I don't want to have a distant ancestor to all my classes that contains this method. The method itself uses reflection to work out the fields and property values that it needs to copy across.

The code is as follows:

public static object GetDeepCopy(this T originalObject, Type newObjectType)
{
  object newObject = Activator.CreateInstance(newObjectType);

  //copy fields
  FieldInfo[] fields = newObject.GetType().GetFields();
  int i = 0;
  foreach (FieldInfo field in fields)
  {
       fields[i].SetValue(newObject, field.GetValue(originalObject));
       i++;
   }

  //copy properties
  PropertyInfo[] properties = newObject.GetType().GetProperties();
   i = 0;
  foreach (PropertyInfo property in properties)
  {
      properties[i].SetValue(newObject, property.GetValue(originalObject, null), null);
       i++;
  }
  return newObject;
}

This class can be used against any classes if it's namespace is included in the code in which you are using the objects. Here is an example of it in use:

ChildClass one = new ChildClass()
{
Active = true,
Address = "HHWWH",
testone = Testy.two,
otherstuff = "sdsadasd"
};

ParentClass two = (ParentClass)one.GetDeepCopy(typeof(ParentClass));

As you can see, the routine requires that a type is passed in and also the returned value must be cast to the same type.

Checking if a string is empty

2008-10-13T03:23:00.000-07:00

In C# there are a variety of ways of checking if a string is empty. The main methods I have seen people use are:

myString == String.Empty;
myString == "";
myString.Length == 0;

So, which is the best one to use? FxCop provides the answer in it's performance rule TestForEmptyStringsUsingStringLength.

As the name probably gives away, the most efficient method is 3. myString.Length == 0; Or alternatively we can use the String.IsNullOrEmpty() method to test that the string isn't null at the same time.

.NET Role Based Security

2008-10-09T06:31:00.000-07:00

I am currently looking at implimenting Users and Security in a new product. Ideally I want to use a Role Based Security (RBS) system, so I've been revisiting the role Based security classes and interfaces that exist in the .NET framework. I have to say that I believe that Microsoft have got this area of the .NET framework wrong *. This is why...

RBS has three components:

The Users
The Roles
The Permissions (AKA rights)

Users are assigned to 0..* roles and roles contain 0..* permissions.
Permissions can be assigned to many roles.
(see the diagram on the wikipedia page here).

In the .NET framework Microsoft have developed classes such as WindowsPrincipal and GenericPrinciple to test whether a User is a member of a particular Role.
For example:

GenericIdentity identity = new GenericIdentity("IMitchell");
string[] roles = new string[] { "Administrator", "Manager" };
GenericPrincipal principle = new GenericPrincipal(identity, roles);

//Imperative Security Check
bool able = principle.IsInRole("Administrator");

//Declarative Security Check
[PrincipalPermission(SecurityAction.Demand, Role="Manager")]
private void DoSomething()
{
....
}

I don't think this is right... I don't think that roles should play a part in the programming. Really you should be checking if the user has the permission to do a certain task. Whether they have that aquired that right from being in role "Administrator" or role "Manager" is irrelevant to the program.

Also, by including security checking based on role names you are imposing these on the end users... who would be far better off defining their own roles to reflect their own organisational structure.

A good example of a good RBS system in operation is in the Oracle Database. In the database various permissions to database objects are automatically defined by the database (e.g. select from aTable, execute stored procedure). Oracle leaves it to the Database Administrator to define their own roles and users and build the association. So one can assume that underneath the hood Oracle is actually checking whether the User has the permission rather than being concerned with how they got it!

I'm not going to be overly critical though, as Microsoft have provided the IPrinciple and IIdentity interfaces to help us build custom implementations of the RBS. I will be using these to develop a permission based checking security system. If I managed to develop this in a non-product specific way I'll post it on this blog in the near future.

* This of course is only my opinion ;)

Why FxCop is essential

2008-09-26T02:17:00.000-07:00

As part of my recent work configuring an automated build server I was asked to ensure that FxCop was run as part of the process. I have had, in previous jobs, experience of FxCop in it's integrated form (as the code analysis tool in Visual Studio Team System). But I have to say it was something that was never used that often and I have to admit most of us ignored what it was saying.

We decided to aim to reduce the FxCop errors in our build report to zero. It seemed a little harsh at first, but I think this is going to seriously help our coding standards.

First off (for all you doubters out there), FxCop is not always right. There are occasions that it is unhappy about something that cannot be changed. For example, we use NUnit for our unit tests and FxCop loves to complain that many of the test methods should be static methods (as they don't reference anything in the class). However, if you convert these to static methods NUnit fails.

Luckily FxCop provides a means to ignore methods that are breaking rules. This is how you do it:

In Visual Studio, open up the .NET project properties and select the Build tab. In the conditional compilation symbols box add CODE_ANALYSIS.
Add using System.Diagnostics.CodeAnalysis; to the code file.
Above the method that is giving the error add a [SuppressMessage] attribute, referencing the FxCop rule assembly, The rule Id/Name and a Justification (this is optional but I strongly recommend this is used so that future developers will know why this isn't being checked). Below is an example from one of my NUnit test files to avoid the previously mentioned static problem:

[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic",
Justification = "FXcop doesn't realise that this Nunit test method cannot be static")]

You can also turn off particular rules from the FxCop configuration tool, or as a command line argument (e.g. /ruleid:-Microsoft.Design#CA1014 The minus before the rule name indicates that this rule should not be used).

This suppression is useful, but don't just suppress every warning and error. This will lose any benefit of running FxCop!

So, what sort of genuine errors has FxCop found? Many are small things like picking up incorrect casing in names of methods, parameters and other class members. These may seem insignificant to the project as a whole but they are key to future developers understanding the project.

Some of the more interesting errors that FxCop has returned have involved Globalisation issues. I have to admit that this is something that is often missed in project development. For example a recent FxCop report noticed that I created a DataTable without specifying a Locale... so what you might say. However, if this isn't set to CultureInfo.InvariantCulture it could effect any sorting performed on this DataTable by users in different locations!

In conclusion, we should be using code analysis tools like FxCop. We may think that our code is perfect, but as the analysis proves, it often is not.

Cryptographic failure while signing assembly (MSBuild / CruiseControl .NET)

2008-09-12T03:54:00.000-07:00

I came across an interesting error through CruiseControl, when I updated one of our assemblies to be signed with a Strong Named Key File. The CruiseControl build report stated:

errorCS1548: Cryptographic failure while signing assembly 'c:\myCheckoutArea\myProject\obj\Debug\myProject.dll' -- 'Access is denied. '

After much searching on the Internet and several red herrings later I finally stumbled across a solution. Simply change the permissions on the %SystemDrive%\Documents and Settings\All Users\Application Data\Microsoft\Crypto\RSA\MachineKeys so that the user has full access to this folder.

NUnit through Visual Studio

2008-09-03T06:04:00.000-07:00

As you may know Visual Studio (VS) has quite nice integration with MSTest projects. It has a test list editor and view that allow you to see the tests in the solution and choose which to run. If any fail you can debug through the tests using the VS debugger.

However, as you may have gathered from previous posts we are using NUnit, basically beacause we don't want to buy an extra VS licence for our automated build machine (yes, thanks Microsoft for not including MSTest in the .NET SDK!).

Thankfully, I have disovered a nice add in for VS called NUnitForVS. This allows NUnit tests to be run and debugged in the same way that MSTest projects are.

Through my install I did discover a couple of issues:

1) You have to manually edit the NUnit Test projects .csproj file to contain a ProjectTypeGuid element. The one specified on the linked website did not work with VS 2008, so I checked one of my MSTest projects and found the following value which did work...

‹ProjectTypeGuid› {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}‹ProjectTypeGuid›

2) My Unit Tests didn't appear at first in the Test View. You have to rebuild the software for it to recalculate the list.

Hint - For ease, I have added a new template project for NUnit tests. This was created as a Class Library, but I have manually edited the .csproj file to contain the ProjectTypeGuid element I mentioned above.

NUnit missing assembly reference error

2008-08-29T04:03:00.000-07:00

Recently I have been getting a few errors running Nunit on our automatic build server. Nunit is being called through an MSBuild file, which is being called by CruiseControl.NET. The CruiseControl build log has been recording the error messages below:

EventLogListenerTest.cs (6,7): errorCS0246: The type or namespace name 'NUnit' could not be found (are you missing a using directive or an assembly reference?)
EventLogListenerTest.cs (18,10): errorCS0246: The type or namespace name 'TestFixtureSetUp' could not be found (are you missing a using directive or an assembly reference?)
EventLogListenerTest.cs (18,10): errorCS0246: The type or namespace name 'TestFixtureSetUpAttribute' could not be found (are you missing a using directive or an assembly reference?)
EventLogListenerTest.cs (25,10): errorCS0246: The type or namespace name 'TestFixtureTearDown' could not be found (are you missing a using directive or an assembly reference?)
EventLogListenerTest.cs (25,10): errorCS0246: The type or namespace name 'TestFixtureTearDownAttribute' could not be found (are you missing a using directive or an assembly reference?)

These errors are only happened when I ran CruiseControl as a service... so I logically assumed that this must be a security issue with the Local service account not being able to see the Nunit assemblies. However, the issue was not resolved by running the service as the logged in user.

The solution I found was to manually add the Nunit.Framework.dll from the Nunit directory in "c:\program files" to the Global Assembly Cache (GAC). This resolved all the missing assembly reference" errors.

XML Namespaces and LINQ to XML

2008-08-20T02:56:00.000-07:00

Recently I've been writing a program to automatically generate an MSBuild file containing all of our projects. This is then used by CruiseControl.NET to continuously build and test our source code.

I decided to use the new LINQ to XML to write the MSBuild file, but came across a problem when I ran the resulting file through MSBuild. The error message I received was:
The element beneath element may not have a custom XML namespace.

Investigation revealed that the root node of the MSBuild XML has a XML namespace (xmlns="http://schemas.microsoft.com/developer/msbuild/2003") and when I added a new XElement to the root element it automatically added a blank namespace attribute to the XElement(xmlns=""). Thus causing the error message.

The solution is to always add a XNamespace object of the SAME address to the XElement you are adding (see below).

XNamespace _xlmns = "http://schemas.microsoft.com/developer/msbuild/2003";

XElement root = new XElement(_xlmns + "Project",
                    new XAttribute("DefaultTargets", "Build");

XElement newBuildTarget = new XElement(_xlmns + "MSBuild",                   
                           new XAttribute("Projects", notShownSolutionPath),
                           new XAttribute("Targets", notShownTargets));
root.Add(XElement);

Bizarrely enough this will actually then remove the xmlns attribute from the added element. But thankfully it solves the problem.

Windows Management Instrumentation (WMI) queries

2008-08-14T01:20:00.000-07:00

Often when coding you need to access the configuration of the server that your software is running on. This might be to determine if a particular device is connected or just to provide remote support information about the machine that the problem occured on.

Microsoft have built a feature called WMI into the Windows Driver Model. This provides an interface which you can query (using WMI queries) to access information about the system and it's components.

.NET provides a namespace (System.Management) that contains classes to query and access the results returned. The example below shows a simple example of using a query in C# to access Drive information on a specific machine.

using System.Management;

public static void DisplayDrives()
{
  ManagementScope scope = new ManagementScope("\\\aMachine\\root\\cimv2");
  ObjectQuery query = new ObjectQuery(
  "SELECT Name, Size FROM Win32_LogicalDisk where DriveType = 3");
      //N.B. 3 = local fixed drives ONLY

ManagementObjectCollection drives = query.Get();
foreach(ManagementObject drive in drives)
  {
   Console.WriteLine(string.Format("Drive:{0} Size={1}",
      drive["Name"].ToString(), drive["Size"].ToString()));
  }
}

As you can see it's quite straightforward to use. However, one of the problems I have come across is how you know that the Win32_LogicalDisk is the object that contains information about the drives?

I use this page, which I found hidden away in the MSDN (I won't start ranting about how difficult it is to find anything in MSDN). It contains a break down of the different types of objects that are available for querying. You can even view the properties they contain.

I've just come across this application that Ben Coleman has created for running WMI queries on local or remote machines. It's quite useful for testing your WMI queries before adding them into your code.

Free Project Management Tools

2008-08-13T00:57:00.000-07:00

I have spent the last few days evaluating free project management tools, as we have decided that we'd like to plan out our latest development in a bit more detail. I've never really been much of a fan of Microsoft Project (a bit to overly complicated), so I have been looking for something that is easy to use and web based.

The solution that I have decided to use is Mingle by Thoughtworks. This is free if you have 5 users, or if you are lucky enough to work for a non-profit or charity. The only requirements are a web server with a mySQL 5.00 database.

Mingle is based around a wiki based system and uses items it calls "Cards" to store information about the project. For example, you can create a card for each of your Use Cases and then add a card property of Requirement status which would allow you to move these cards through pre-defined project states (such as Analysis, Design, Implementation and Completed). You can even create card trees, which in this example would allow you to break the Requirement into software engineering tasks (such as Code, Unit Test etc).

Cards can also be used to keep track on defects and other project items. Mingle is highly configurable and can be adapted to a variety of project management uses. Thoroughly recommended.

Custom Event Log Trace Listener

2008-08-06T03:24:00.000-07:00

We all love .NET tracing, who wouldn't? It's so easy to use (see here if you've never come across tracing before).

However, recently I've come across a mild annoyance. The standard .NET event log listener logs everything as info... great!

Luckily the .NET framework provides the ability to write your own custom trace listeners, so I decided to write my own. I have included the code for this trace listener below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace aCompany.Diagnostics
{
 public class EventLogListener: TraceListener
 {
     #region Field(s)
     private EventLog _eventLog;
     #endregion

     #region Constructor(s)
     public EventLogListener(string sourceName)
     {
         _eventLog = new EventLog();
         _eventLog.Source = sourceName;
     }
     #endregion

     #region Public Method(s)
     public override void Write(string message)
     {
         _eventLog.WriteEntry(message, EventLogEntryType.Information);
     }

     public override void WriteLine(string message)
     {
         this.Write(message + Environment.NewLine);
     }

     public override void Fail(string message)
     {
         _eventLog.WriteEntry(message, EventLogEntryType.Error);         
     }

     public override void Fail(string message, string detailMessage)
     {
         _eventLog.WriteEntry(message + Environment.NewLine + detailMessage, EventLogEntryType.Error);
     }

     public override void WriteLine(string message, string category)
     {
         EventLogEntryType entryType = (EventLogEntryType)Enum.Parse(typeof(EventLogEntryType), category);
         _eventLog.WriteEntry(message, entryType);
     }
     #endregion  
 }
}

This listener assumes that an info event should be created if a Trace.Write() or Trace.WriteLine() is called. An error event is created if Trace.Fail() is called.

There is also a WriteLine() that takes a category as an argument. I have used this to represent a string of EventLogEntryType, so this can be used to created any type of event.

The event source that the events will be added to is passed in as an argument to the constructor.

Hope you find this useful.

Visual Studio 2008 Test List Editor Bug

2008-07-28T03:49:00.001-07:00

Monday morning: After another weekend of travelling around the country (this time London) I have returned to work and discovered a juicy bug in Visual Studio 2008. (VS)

I noticed that when I closed my projects and reopened them, all the Unit Test lists disappeared from my Test List! Investigation revealed that VS had actually replaced the vsmdi file (myProject.vsmdi) with a new one (myProject1.vsmdi). To get the original test list back you have to delete this new one and re-add the original one from the project directory.

A temporary work around to get around the issue is to close the Test List Editor prior to closing the solution/project or VS.

I've checked on Microsoft's connect website and this has already been reported. Interestingly enough I came across this post by Aaron Stebner (here!) about best practice when logging a Bug with Microsoft.

In the beginning there was light...

2008-07-25T03:31:00.000-07:00

I have been meaning to start putting together a blog for many years now. Finally, one quiet day in the office I have finally put this together!

So to start I have prepared a question and answer session with myself. Don't worry I haven't got multiple personalities.

Q. Why as a so called software engineer (SE) have you used the google blogging site rather than create your own site using this or that blogging software?
A. Okay I'm a bit lazy... also on a more serious note I think there is a mindset amongst many SE to always go and reinvent the wheel. If google are providing this (seems to be decent) service free of charge then why should I mess around with my own site :).

Q. What is this blog for? Do we really need to hear the rantings of another person?
A. Well I want to use this to share my experiences of Software Development.. and hopefully these will help other SE solve there issues. Also, I want to add some more real life examples of using analysis and design to build "quality" software. It seems that there is a real lack of blogs that tackle this subject.

Q. Who are you and why should we listen to you?
A. I am a Senior Software Engineer who is currently working for a small expense managment firm in Manchester, UK. Before this role I was working for large firms in the Pharmaceutical sector. I am currently working with C# and ASP.NET and have previous experience working with Delphi and Java. Through all my career (6 years) I have used UML and Oracle Databases. I have also been involved in training SE in UML and Object-Oriented analysis and design.
In answer to the other question... errr... you don't have to listen to me if you don't want to :)