Cedar City Group

Interpolate is available!

2009-01-24T17:07:00.005-06:00

Several years ago, I worked for a company that sold some small hand held computers made by Sharp. They were pretty fascinating devices for the time. The PC-1262 was by far the most popular.

I wrote some small utilities for use by medical physicists and we sold quite a few of them. I had several ideas for products that would cater to engineers and scientists of all types, but we couldn't really get the ideas going into full fledged products.

David Hinson, is a friend of mine in Florida who is focused on iPhone development among other things. I ran an idea by him that I had way back when and in a matter of a few weeks, we have a product available for the iPhone called 'Interpolate'.

This application allows the user to store known data points for multiple datasets and then allows them to obtain values for unknown points. Believe it or not, there are people that need that sort of thing.

Here's a demo....

It is available on iTunes, buy it today!

Avoiding object aliasing....

2009-01-14T07:39:00.002-06:00

Aliasing is a fancy term for referring to the same object by two different names. Sometimes it can be useful, most times it will causes some unintended consequences. As frameworks become more and more complex, with objects pointing to other objects (referred to as graphs) the potential for aliasing increases.

Sometimes, you want to create a totally new instance of an object graph, but programming something list this can be very tricky. Luckily, serialization gives us a very quick and easy way to perform a 'deep copy' of an object graph regardless of how complex it is.

Below is my DeepCopy class and its associated test...


using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

namespace ccglib
{
    public class DeepCopy<T>
    {
        // create a new graph with new instances of all objects
        public static T Copy(T graph)
        {
            T newgraph;
            MemoryStream ms = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(ms,graph);
            ms.Seek(0, SeekOrigin.Begin);
            newgraph = (T)formatter.Deserialize(ms);
            ms.Dispose();
            return newgraph;            
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;
using ccglib;

namespace ccglibtests
{
    [Serializable]
    public class class1
    {
        public int x;
        public int y;
        public class2 z;         
    }

    [Serializable]
    public class class2
    {
        public int a;
        public int b;
    }

    [TestFixture]
    public class deepcopytest
    {
        [Test]
        public void aliastest()
        {
        class1 obj1 = new class1();
        class2 obj2 = new class2();
        class1 alias;
        class1 deepcopy;

            // create a simple object graph
        obj1.x = 1;
        obj1.y = 2;
        obj2.a = 3;
        obj2.b = 4;
        obj1.z = obj2;

        alias = obj1;
        deepcopy = DeepCopy.Copy(obj1);

        alias.x = 10;
        deepcopy.x = 100;
        Assert.AreEqual(alias.x, obj1.x);
        Assert.AreNotEqual(deepcopy.x, obj1.x);

        alias.z.a = 40;
        alias.z.a = 400;
        deepcopy.z.a = 4000;

        Assert.AreEqual(alias.z.a, obj1.z.a);
        Assert.AreNotEqual(deepcopy.z.a, obj1.z.a);
        }        
    }
}

Not to state the obvious, but all involved classes need to be serializable...

Abstraction...

2009-01-14T03:59:00.013-06:00

One of the important basic principles of computer science is abstraction. Following is the text book definition....

abstraction is a mechanism and practice to reduce and factor out details so that one can focus on a few concepts at a time.

Back in my college days, we studied this intently. The languages available at the time didn't support the concept as well as the languages do today. But we did the best we could using the languages that we had available.

One of my favorite courses was data structures, in that class we studied different ways to store data to achieve different goals. We studied, linked lists, stacks, queues and the like. We were given the opportunity to develop our own data structures based on the problem we were given.

The primary teaching language for teaching computer science at that time was Pascal, but we were exposed to many different languages. In my last semester, the teacher was pushing a class in the Ada language (a huge language developed by the DoD), on a whim I also took a class in an emerging language called C.

Although I've never heard of a job requesting experience in the Ada language, I'm grateful for the class. The Ada language was the first object oriented language we studied (this was 1986) and allowed advanced concepts like like operator overloading and generics. The Ada compilers were in beta testing at that time so actually developing a program in Ada was difficult, but the concepts were crucial.

Today, C# provides a lot of the same features that we studied back then, so I've taken a little bit of time to dig into generics. Generics are the ultimate level of abstraction because the algorithm is completely divorced from the data type. If you look at the concept of the simple List in System.Collections.Generic, you see what I mean. Even if you create your own class, you can easily create a type safe collection of them. If your class can be compared, the collection will even sort them for you. Very powerful if you ask me.

But simple collections are not the only application of generics, any data structure that you may want create can be created such that the data structure and its associated operations are completely divorced from the class that is stored in it.

I'm sure there are thousands of implementations of the mathematical concept of sets out there, but this was one of the first generic data structure that I decided to implement. Below is the code, the namespace is a reference to my roots in the Pascal language...

For definition of some of the basic mathematical concepts check out Set theory basic concepts


using System;
using System.Collections.Generic;
using System.Text;

namespace ccg.paslib
{
    public class Set<T> 
    {
        List<T> _internallist = new List<T>();

        
        // add a member                
        public void Add(T parm)
        {
            _internallist.Add(parm);
        }


        // remove a member
        public void Remove(T parm)
        {
            _internallist.Remove(parm);
        }
        

        // is the supplied value a member of this set?
        public bool Contains(T parm)
        {
            return _internallist.Contains(parm);
        }

        // returns the Union of two sets
        public Set<T> Union(Set<T> parm)
        {
            Set<T> retval = new Set<T>();
            foreach (T val in _internallist)
                retval.Add(val);
            foreach (T val in parm)
                if (!retval.Contains(val))
                    retval.Add(val);
            return retval;
        }


        // returns the intersection of two sets
        public Set<T> Intersection(Set<T> parm)
        {
            Set<T> retval = new Set<T>();
            foreach (T val in _internallist)
                if (parm.Contains(val))
                    retval.Add(val);
            return retval;
        }


        // returns the difference between two sets
        public Set<T> Difference(Set<T> parm)
        {
            Set<T> retval = new Set<T>();
            foreach (T val in _internallist)
                if (!parm.Contains(val))
                    retval.Add(val);
            return retval;
        }

        // return members that are in one set but not both
        public Set<T> ExclusiveOr(Set<T> parm)
        {
            Set<T> retval = new Set<T>();
            foreach (T s in this)
                if (!parm.Contains(s))
                    retval += s;
            foreach (T s in parm)
                if (!this.Contains(s))
                    retval += s;
            return retval;
        }


        // return an enumerator for the set
        public List<T>.Enumerator GetEnumerator()
        {
            return _internallist.GetEnumerator();
        }


        // return the number of members in the set
        public int Count
        {
            get { return _internallist.Count; }
        }

        #region operators
        public static Set<T> operator +(Set<T> set, T value)
        {            
             set.Add(value);
             return set;
        }

        public static Set<T> operator +(Set<T> set1, Set<T> set2)
        {
            return set1.Union(set2);
        }

        public static Set<T> operator -(Set<T> set1, Set<T> set2)
        {
            return set1.Difference(set2);
        }

        public static Set<T> operator *(Set<T> set1, Set<T> set2)
        {
            return set1.Intersection(set2);
        }

        public static Set<T> operator ^(Set<T> set1, Set<T> set2)
        {
            return set1.ExclusiveOr(set2);
        }
        #endregion

    }
    

    // generic class to create an ordered pair of objects for the Catesian Product
    public class OrderedPair<T, S>
    {
        public T A;
        public S B;
    }


    // Generic static class to implement the catesian product
    public class CartesianProduct<T,S>
    {
        public static Set<OrderedPair<T,S>> Product(Set<T> a,Set<S> b)
        {
            Set<OrderedPair<T,S>> retval = new Set<OrderedPair<T,S>>();
            foreach(T i in a)
                foreach(S j in b)
                {
                    OrderedPair<T,S> value = new OrderedPair<T,S>();
                    value.A = i;
                    value.B = j;
                    retval.Add(value);
                }
            return retval;
        }
    }
   
}

So, how can this be used? Does the mathematical concept of a set have anything to do with software development? Absolutely....at its core, a relational database is based on set theory. Below are some of the NUnit tests that I wrote for testing this class.


        [Test]
        public void uniontest()
        {
            Set<Color> set1 = new Set<Color>();
            Set<Color> set2 = new Set<Color>();

            set1.Add(Color.Red);
            set1.Add(Color.Blue);
            set2.Add(Color.Green);
            set2.Add(Color.White);

            Set set3 = set1.Union(set2);
            Assert.AreEqual(set3.Count, 4);
            foreach (Color val in set3)
                Assert.IsTrue(set1.Contains(val) || set2.Contains(val));
        }

        [Test]
        public void intersectiontest()
        {
            Set<Color> set1 = new Set<Color>();
            Set<Color> set2 = new Set<Color>();

            set1.Add(Color.Red);
            set1.Add(Color.Blue);
            set2.Add(Color.Blue);
            set2.Add(Color.Green);
            set2.Add(Color.White);

            Set<Color> set3 = set1.Intersection(set2);
            Assert.IsTrue(set3.Count == 1);
            foreach (Color val in set3)
                Assert.IsTrue(val.Equals(Color.Blue));
        }

        [Test]
        // test some of the operators
        public void exclusiveortest()
        {
            Set<Color> set1 = new Set<Color>();
            Set<Color> set2 = new Set<Color>();

            set1 += Color.Red;
            set1 += Color.Blue;
            set2 += Color.Blue;
            set2 += Color.Green;
            set2 += Color.White;

            Set<Color> set3 = set1 ^ set2;
            Assert.IsTrue(set3.Count == 3);
            Assert.IsTrue(set3.Contains(Color.Red));
            Assert.IsTrue(set3.Contains(Color.Green));
            Assert.IsTrue(set3.Contains(Color.White));
        }

The OrderedPair<T, S> and CartesianProduct<T,S> classes are pretty interesting. Below is a test that I wrote for that class.


        [Test]
        public void caresianproducttest()
        {
            Set<DateTime> set1 = new Set<DateTime>();
            for (int i = 0; i < 10; i++)
                set1.Add(new DateTime(2009, 1, 1).AddDays(i));

            Set<Color> set2 = new Set<Color>();
            set2.Add(Color.Blue);
            set2.Add(Color.Red);
            set2.Add(Color.Green);

            Set<OrderedPair<DateTime, Color>> set3 = CartesianProduct<DateTime, Color>.Product(set1, set2);

            Assert.AreEqual(set3.Count, set1.Count * set2.Count);
        }

So, now what? Just like the List<T> generics, the Set<T> generic can be used with custom written classes. There is a caution here though. The default implementation of the Equals() method tests that the reference of two objects are equal. In other words, if you have two instances of a class that contain the same data, the default implementation of Equals() will return false because they are different instances. For the Set<T> generic to work as expected on custom classes, you must override the default implementation of Equals. Below is an example...


      public class Customer
        {
            // public member variable violate the concept of abstraction, 
            // but this is just a test, not production code
            public int ID;
            public string Name;

            public Customer(int id, string name)
            {
                ID = id;
                Name = name;
            }

            public override bool Equals(object obj)
            {
                Customer objvalue = (Customer)obj;
                return this.ID == objvalue.ID;
            }
                       
        }

        [Test]
        public void CustomObjectTest()
        {
            Set<Customer> set1 = new Set<Customer>();
            set1 += new Customer(1, "customer 1");
            set1 += new Customer(2, "customer 2");
            set1 += new Customer(3, "customer 3");

            Set<Customer> set2 = new Set<Customer>();
            set2 += new Customer(2, "customer 2");

            // without overriding Equals() set3 contains all three members
            Set<Customer> set3 = set1 - set2;
            Assert.AreEqual(set3.Count, 2);
            Assert.IsTrue(set3.Contains(new Customer(1,"customer 1")));
            Assert.IsTrue(set3.Contains(new Customer(3,"customer 3")));            
        }

Combining custom objects with the concepts of Set Theory, allows some sophisticated operations to be performed using simple mathematical operators.

Geeks gone wild....

2009-01-13T13:48:00.004-06:00

I have a friend named David Hinson who moved from the Nashville area to Florida some time last year. David and I worked together back when processor speeds were measured in mHz.

Anyway, Dave is seriously into developing applications for the iPhone and seemed to be searching for ideas for new applications. I ran an idea by him that I had thought of for years before never found a reasonable platform for developing it.

I sent Dave some code and he ran with it....this may be coming to iPhone app store soon.

If there were more than 6 people on the planet that would use something like this, we'd be rich.

Interpolate Demo

New Resume....

2009-01-08T23:01:00.004-06:00

This week, I spent a significant amount of time reformatting my resume. The previous format was confusing to some because the projects that I have completed were separated from the places I had worked. I did this in an effort to keep the resume short. This version provides a lot more detail and shows the projects that I have done in chronological order.

I am currently seeking new opportunities, if you are currently beginning new projects, or have any needs in the area of technology, I would appreciate your consideration.

Donnie

A Time For Reflection (Factory Pattern in Action part 3)

2009-01-04T21:24:00.013-06:00

For a preview of the application being discussed here please visit this page

The preceding portions of this series can be found here and here.

Setting properties on Factory Generated Objects
The grayscale and sepia objects were unique in that they do not require any parameters to operate. They know what they are supposed to do and can do it with no input provided by the controlling object. But, it should be obvious that to be useful, some objects will need to have some input provided. If the a factory returns only a base type, how can you set a property on a returned object without breaking the barrier of anonymity that the factory pattern provides?

Interfaces provide a possible solution, and possibly a better solution from a type safety perspective. However, in the interest of making the coupling as loose as possible, I have chosen to use reflection as the means of communicating with the object returned from the factory pattern.

For this portion, I selected to use a couple of filters that modify the colors in bitmap. The first filter can lighten or darken a photo using a gamma correction. The gamma value must be greater than 0. A gamma value of 1.0 leaves the image unchanged, values less than 1 lighten the images, values greater than 1.0 darken the image. Following is the code for my LightenDarken filter.


using System;
using System.Collections;
using System.Runtime.Serialization;
using System.Drawing.Imaging;
using System.Drawing;

namespace ccg.imaging
{
 /// 
 /// Performs a gamma correction on the processed image
 /// 

 /// 
 [Serializable]
 [NameAttribute("Ligthens or Darkens an image")]
 [DescriptionAttribute("Adjusts the brightness of the entire image.")]
 public class LightenDarken: ImageProcessBase
 {
  public LightenDarken()
  {
   
  }

        public LightenDarken(float gamma)
        {
            _gamma = gamma;
        }

        float _gamma = 1.0f;

        public float Gamma
        {
            set { _gamma = value; }
            get { return _gamma; }
        }
   
  protected override System.Drawing.Bitmap ProcessSafe(System.Drawing.Bitmap bitmapin)
  {               
   System.Drawing.Bitmap outmap = new System.Drawing.Bitmap(bitmapin.Width,bitmapin.Height);
   Graphics g = Graphics.FromImage(outmap);
            ImageAttributes ia = new ImageAttributes();
            ia.SetGamma(_gamma);
            g.DrawImage(bitmapin,new Rectangle(0,0,outmap.Width, outmap.Height),0,0,
                        bitmapin.Width,bitmapin.Height,GraphicsUnit.Pixel,ia);
   g.Dispose();
   
   return outmap;
  }
 }
}

The class allows the gamma value to be set in the constructor, but also allows it to be set as a property. Since the factory returns an ImageProcessBase type, the Gamma property is not available directly. The property could be set directly, but to do that, the controlling code would need to know the name of the class returned by the factory. In my opinion, this forces the controlling code to know too much about the underlying implementation of the filter. The most loosely couple approach is to set the property using reflection. The controlling code can retrieve the Type information from the class and use that to set the property using reflection.


    ImageProcessBase proc = filterfactory.ActivateFilter("lightendarken");
    Type t = proc.GetType();
    object[] parms = { gamma };   // gamma declared and initialized earlier
    t.InvokeMember("Gamma", System.Reflection.BindingFlags.SetProperty,
                   null, proc, parms);
    output = proc.Process(output);

This approach has its downfalls, the main one being that if the property name is changed on the LightenDarken class, then the problem will show up at run time instead of compile time. However, this approach requires the least amount of information to be known be the controlling code. Casting or using interfaces requires the controlling code to know the name of the class or interface and the name of the property. Using reflection requires only the name of the property to be known. Since loose coupling is my primary design goal, this is the approach I selected.

The second filter uses the ColorMap property of the ImageAttributes class in the .NET framework to modify the colors in the bitmap. The ColorMap property of the ImageAttribute class allows you to specify a 'from' color and a 'to' color. When the bitmap is regenerated in the DrawImage call, this color mapping is used. My original intentions was to use it to reduce the number of shades of grey in an image my mapping multiple 'from' colors to the same 'to' color. However, I found it to be much more useful than just that. By supplying different ColorMaps, this filter can achieve some pretty cool effects. To make this simpler, I created an abstract class called ColorMapper. The only abstract method is the protected initializecolormap method.


using System;
using System.Drawing;
using System.Collections;
using System.Drawing.Imaging;

namespace ccg.imaging
{
 /// 
 /// This is an abstract class to allow the creation of multiple colormapping 
        /// classes
 /// 

 /// 
 [NameAttribute("ColorMapper")]
 [DescriptionAttribute("Maps Colors within a bitmap to different colors")]
 [Serializable]
 public abstract class ColorMapper: ImageProcessBase
 {
  
        #region Constructors
        public ColorMapper()
        {
        }
  
        #endregion
       
        //--- create the color mapping
        protected abstract ColorMap[] initializecolormap(Bitmap bitmapin);  

        /// 
        /// process the incoming image to map colors to different colors
        /// 
        
 protected override System.Drawing.Bitmap ProcessSafe(System.Drawing.Bitmap
                                                             bitmapin)
 {   
            ImageAttributes ia = new ImageAttributes();
            ia.SetRemapTable(initializecolormap(bitmapin));
            Bitmap outimg = new Bitmap(bitmapin.Width,bitmapin.Height);
            Graphics g = Graphics.FromImage(outimg);
            g.DrawImage(bitmapin, new Rectangle(0, 0, outimg.Width, 
                        outimg.Height), 0, 0, bitmapin.Width, bitmapin.Height, 
                        GraphicsUnit.Pixel, ia);
            g.Dispose();
            return outimg;
 }    
    }
}

With this base class, we can easily produce a couple of color mapping effects. ShadeReducer maps multiple 'from' colors to the same 'to' color to reduce the number of shades in a grayscale bitmap. ColorShift uses the specified BaseColor as the color to shade rather than Black.


using System;
using System.Drawing;
using System.Collections;
using System.Drawing.Imaging;

namespace ccg.imaging
{
   /// 
   /// Summary description for ShadeReducer
   /// 

   /// 
  [NameAttribute("Shade Reducer")]
  [DescriptionAttribute("Reduces the image to the specified number of shades")]
  [Serializable]
  public class ShadeReducer: ColorMapper
    {
 //--- default number of shades of no value is provided
 int _numberofshades = 255;

        #region Constructors
        public ShadeReducer()
        {
        }

 public ShadeReducer(int numberofshades)
 {
   _numberofshades = numberofshades;
        }
        #endregion

        /// 
        /// Property to set the number of shades to use
        /// 

        public int NumberOfShades
        {
            get { return this._numberofshades; }
            set { this._numberofshades = value; }
        }

        //--- create the color mapping
        protected override ColorMap[] initializecolormap(Bitmap bitmapin)
   {            
            ColorMap[] cmarray = new ColorMap[255];
            int newvalue;
            int shadeincrement = (255 / _numberofshades);
            for (int i = 254; i >= 0; i--)
              {
              ColorMap cm = new ColorMap();
              cm.OldColor = Color.FromArgb(i, i, i);
              newvalue = 255-(shadeincrement * ((254-i) / shadeincrement));
              cm.NewColor = Color.FromArgb(newvalue, newvalue, newvalue);
              cmarray[i] = cm;                 
              }
            return cmarray;            
          }         
     }
}


using System;
using System.Drawing;
using System.Collections;
using System.Drawing.Imaging;

namespace ccg.imaging
{
 /// 
 /// Summary description for ShadeReducer
 /// 

 /// 
 [NameAttribute("Color Shifter")]
 [DescriptionAttribute("Converts a grayscale bitmap to shades of the specified Base Color")]
 [Serializable]
 public class ColorShifter: ColorMapper
 {  
        Color _basecolor = Color.FromArgb(0x000000);

        #region Constructors
        public ColorShifter()
        {
        }  
        #endregion

        public Color BaseColor
        {
            get { return _basecolor; }
            set { _basecolor = value; }
        }

        /// 
        /// This method produces as many shades of the basecolor as possible
        /// The BaseColor will be the darkest color in the bitmap.
        /// The method will produce as many shades as possible of the color
        /// without changing it
        /// 
        
        private Color GetColorShade(Color colortoshade, int shadevalue)
        {
            int redvalue = colortoshade.R + shadevalue;
            int greenvalue =  colortoshade.G + shadevalue;
            int bluevalue =  colortoshade.B + shadevalue;

            if (redvalue > 255)
            {
                greenvalue -= redvalue - 255;
                bluevalue -= redvalue - 255;
                redvalue = 255;
            }

            if (greenvalue > 255)
            {
                bluevalue -= greenvalue - 255;
                redvalue -= greenvalue - 255;
                greenvalue = 255;
            }

            if (bluevalue > 255)
            {
                redvalue -= bluevalue - 255;
                greenvalue -= bluevalue - 255;
                bluevalue = 255;
            }
            return Color.FromArgb(redvalue, greenvalue, bluevalue);            
        }

        //--- create the color mapping
        protected override ColorMap[] initializecolormap(Bitmap bitmapin)
          {            
            ColorMap[] cmarray = new ColorMap[255];
            int newvalue;
            int shadeincrement = (255 / _numberofshades);
            for (int i = 0; i < 255; i++)
            {
                ColorMap cm = new ColorMap();
                cm.OldColor = Color.FromArgb(i, i, i);
                cm.NewColor = GetColorShade(_basecolor, i);
                cmarray[i] = cm;                 
            }
            return cmarray;            
          }         
     }
}

The controlling code can use reflection to set the NumberOfShades and BaseColor properties as needed.

The example of these filters in action is available at http://www.cedarcitygroup.com/digitaldarkroom/uncolormyworld.aspx. The .NET framework provides a tremendous amount of flexibility in processing images. Breaking different operations down into filters allows them to be mixed and matched into a processing pipeline that can be applied to a large number of images easily.

I hope that this series has been beneficial. Be on the lookout for an image processing utility for webmasters available here soon.

I just got my hands on some numerical analysis code that I wrote 20 years ago in Pascal. I'm dying to convert it to C#, there will be some posts about it soon as well.

First attempt at flash training....

2009-01-01T09:33:00.002-06:00

I put this flash movie together as a follow up to a post that I did on my personal blog. Like a lot of computer guys, I'm a frustrated musician. Flash is pretty cool because I can utilize my hobbies and profession into one medium. I used audactity to record and process the audio, Flash CS3 to put it all together. I learned a ton by doing it. I need to figure out the synchronization of audio and animation thing though. It's synchronized during development, but one seems to get ahead of the other after publishing. I'm going to figure that out...Any comments or tips are appreciated...

Uncolor My World, The Factory Pattern In Action part 2

2008-12-28T21:43:00.036-06:00

For a preview of the result of this rather long post, please visit
http://www.cedarcitygroup.com/digitaldarkroom/uncolormyworld.aspx

In the days of film photography, black and white photos were considered of higher quality than color photos. Many professional photographers, most notably Ansel Adams, would only shoot black and white photos. In the film days, color negatives could be used to make black and white prints by using black and white paper. To achieve the highest quality prints, however, black and white negatives were used.

But in the days of digital photography, how do you convert a color photograph to black and white?

First attempt, Pixel by Pixel
Just to review, each pixel in color jpeg bitmap is represented by four bytes, the color of the pixel is represented by three bytes, one byte for each of the colors (red, green and blue) The fourth bytes is used to control the opacity of the pixel, commonly referred to as the alpha value. Each byte contains a value from 0 to 255. When the red, green and blue components are the same, the result is a shade of gray ranging from 0x000000 for black to 0xFFFFFF for white. The task of converting a color bitmap to a grayscale bitmap involves using the values of the red, green and blue components of a pixel to compute a shade of gray to be used to accurately represent that color. Based on some analysis that I don't completely understand, a formula to do this turns out to be:

shadeofgray = 0.212671f * red + 0.715160f * green + 0.072169f * blue;

When I initially wrote this filter, I implemented it using a brute force method of computing the grayscale value pixel by pixel. This was the primary reason that I added the code to the ImageProcessBase class to allow unsafe code. After doing some research, I found that the .NET framework provides a high speed method of achieving the same effect, using only managed code.

Dust off your Linear Algebra textbook
The System.Drawing namespace provides the ColorMatrix class that can be used to manipulate colors during the rendering of a bitmap. You can find a pretty good explanation of the ColorMatrix class and the mathematics behind it here. For our purposes, I'll just show the code for my grayscale class.



using System;
using System.Collections;
using System.Runtime.Serialization;
using System.Drawing.Imaging;
using System.Drawing;

namespace ccg.imaging
{
 /// 
 /// Converts a color image into a grayscale image
 /// 

 /// 
 [Serializable]
 [NameAttribute("Convert To Grayscale")]
 [DescriptionAttribute("Converts the incoming image to a grayscale image.")]
 public class Grayscale: ImageProcessBase
 {
  public Grayscale()
  {
   
  }
 
  protected override System.Drawing.Bitmap ProcessSafe(System.Drawing.Bitmap bitmapin)
  {
               
    ColorMatrix cm = new ColorMatrix();           

    cm.Matrix00 = 0.212671f;
    cm.Matrix01 = 0.212671f;
    cm.Matrix02 = 0.212671f;
    cm.Matrix10 = 0.715160f;
    cm.Matrix11 = 0.715160f;
    cm.Matrix12 = 0.715160f;
    cm.Matrix20 = 0.072169f;
    cm.Matrix21 = 0.072169f;
    cm.Matrix22 = 0.072169f;

    System.Drawing.Bitmap outmap = 
              new System.Drawing.Bitmap(bitmapin.Width,bitmapin.Height);
    Graphics g = Graphics.FromImage(outmap);
    ImageAttributes ia = new ImageAttributes();
    ia.SetColorMatrix(cm);
    g.DrawImage(bitmapin,new Rectangle(0,0,outmap.Width,
              outmap.Height),0,0,bitmapin.Width,
              bitmapin.Height,GraphicsUnit.Pixel,ia);
    g.Dispose();
   
    return outmap;
  }
 }
}

What can Brown do for you?
In the early days of photography, prints were toned with Sepia as a preservation technique. The original black and white prints were soaked in a solution made from the Sepia officinalis cuttlefish that produced prints that were more resistant to breakdown over time. The result was a brown tinted printed instead of gray. The result was beautiful in many ways. Today, many photos are converted to a Sepia tone to simulate this old fashioned beauty. By changing the values in the ColorMatrix, the same code will generate a Sepia toned bitmap.



using System;
using System.Collections;
using System.Runtime.Serialization;
using System.Drawing.Imaging;
using System.Drawing;

namespace ccg.imaging
{
 /// 
 /// Converts a color image into a sepia image
 /// 

 /// 
 [Serializable]
 [NameAttribute("Convert To Sepia")]
 [DescriptionAttribute("Converts the incoming image to a sepia image.")]
 public class Sepia: ImageProcessBase
 {
  public Sepia()
  {
   
  }
   
  protected override System.Drawing.Bitmap ProcessSafe(System.Drawing.Bitmap bitmapin)
  {   
     ColorMatrix cm = new ColorMatrix();
            
     cm.Matrix00 = 0.393f;
     cm.Matrix01 = 0.349f;
     cm.Matrix02 = 0.272f;
     cm.Matrix10 = 0.769f;
     cm.Matrix11 = 0.686f;
     cm.Matrix12 = 0.534f;
     cm.Matrix20 = 0.189f;
     cm.Matrix21 = 0.168f;
     cm.Matrix22 = 0.131f;     

     System.Drawing.Bitmap outmap = new  
            System.Drawing.Bitmap(bitmapin.Width,bitmapin.Height);
     Graphics g = Graphics.FromImage(outmap);
     ImageAttributes ia = new ImageAttributes();
     ia.SetColorMatrix(cm);
     g.DrawImage(bitmapin,new Rectangle(0,0,outmap.Width,
             outmap.Height),0,0,bitmapin.Width,bitmapin.Height,GraphicsUnit.Pixel,ia);
     g.Dispose();
   
     return outmap;
  }
 }
}

Keeping it loose
Now that we have a couple of classes that actually manipulate images, it's time to take a look at the factory itself. 'Loose Coupling' is a term that you may hear a lot in development circles. The basic idea is to reduce the amount of information shared between components of an application. This allows changes to be made to one component without forcing changes or even recompilation of other components. This is what the factory pattern is all about.

In this application, I have elected to place all of the shared information in a separate dll called ccg.imaging.foundation. This dll contains all of the base classes and the factory itself (for now). A reference to this dll will need to be added to any application (winforms or webforms) that intends to use the ccg.imaging components. Any dll projects that implement the abstract classes will also need to reference the foundation dll. The important point here is that it is not necessary for the application to directly reference any other imaging dlls. The factory class can use reflection to activate the processing components providing the ability to update the component dlls without recompiling the entire application. I've created a FactoryBase class to provide some basic Factory services.



using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace ccg.imaging
{
   
    public class FilterFactoryBase
    {
        // a dictionary used to store object specifications
        private Dictionary<string, string> _filters = null;

        protected FilterFactoryBase()
        {
            _filters = new Dictionary<string,string>();
        }

        // a method provided so that the subclassed factory can provide an
        // application dependent id for the class, the fully qualified name of 
        // the class and the path to the assembly that contains the class
        protected void AddFilter(string id, string classname, string assemblypath)
        {
            // store the path and classname in the dictionary using a delimited string
            _filters.Add(id, assemblypath + "|" + classname);
        }


        // a method to activate a class identified by the application specified id
        public ImageProcessBase ActivateFilter(string id)
        {
            ImageProcessBase objfilter = null;

            // retrieve the specification from the dictionary
            string classspec = _filters[id];
            try
            {
                // if the classspec is found
                if (!string.IsNullOrEmpty(classspec))
                {
                    // break the stored spec down into its components (see AddFilter() method)
                    string[] typespec = classspec.Split('|');
                    string assemblypath = typespec[0].Trim();
                    string classname = typespec[1].Trim();
                    
                    // make sure the needed assembly is loaded
                    Assembly remoteassembly = Assembly.LoadFrom(assemblypath);
                    // retrieve the Type from the assembly
                    Type remotetype = remoteassembly.GetType(classname);
                    // create an instance of the class
                    objfilter = (ImageProcessBase)Activator.CreateInstance(remotetype);
                }
            }
            catch 
            {
                
            }

            // will be null if the class is not found or cannot be activated
            return objfilter;
        }
    }
}

Now all the FilterFactory subclass needs to do is provide the application defined id, the class name and assembly path for each class that it wants to activate.



using System;
using System.Collections;
using System.Collections.Generic;

namespace ccg.imaging
{
 /// 
 /// This Class provides a  means to find out what filters are available
 /// and what they do.
 /// 

 public class FilterFactory: FilterFactoryBase
 {  
  public FilterFactory()
  {
     string dllpath = AppDomain.CurrentDomain.BaseDirectory +
            "bin\\ccg.imaging.dll";
     AddFilter("grayscale", "ccg.imaging.Grayscale", dllpath );
     AddFilter("sepia", "ccg.imaging.Sepia", dllpath);  
  } 
 }
}

Pulling it all together
http://www.cedarcitygroup.com/digitaldarkroom/uncolormyworld.aspx is an example web page that uses these classes to manipulate a fixed image according to gestures made on the user interface.

The main aspx page places the name of the image to be used in a session variable and provides the user input controls. An image tag is present with its source set to a second aspx page where all the magic happens. When the process button is pressed, the source for the image tag is changed so that the user's selections are passed to the processing page in the form of url parameters. Following is the code for the processing page.



using System.Configuration;
using System.Collections;
using System.Web;
using ccg.imaging;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

public partial class digitaldarkroom_darkroomprocess : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        // load the image using a utility class to resolve pathname and whatnot
        darkroombl bl = new darkroombl();
        Bitmap output = bl.GetImage(Request["image1"].ToString());

        // use the colorization command to obtain the object to use 
        //to implement the command
        string colorcommand = Request["color"].ToString().ToLower();

        // if the user specifies "full color", then we need to do nothing
        if (!string.IsNullOrEmpty(colorcommand) && !colorcommand.Equals("full color"))
        {
            // instantiate the factory
            FilterFactoryBase filterfactory = new FilterFactory();
            // activate the class based on the user's input
            ImageProcessBase proc = filterfactory.ActivateFilter(colorcommand);
            //process the image
            output = proc.Process(output);
        }
        
        // send the resulting image back as a jpeg
        Response.ContentType = "image/jpeg";
        MemoryStream ms = new MemoryStream();
        output.Save(ms,ImageFormat.Jpeg);
        ms.WriteTo(Response.OutputStream);

    }
}

What does all this banjo work give us?
So, what is the final result?

1. The application that uses the image process classes does not need to have a reference to the assembly they are located in. Only the ccg.imaging.foundation is referenced by the top level project. Additional filters can be added to the dll without reguiring the application to be rebuilt.

2. The factory class only requires string values to be initialized. Right now, the class specifications are hard coded in the factory's constructor. They could be read from the web.config file or even loaded from a database.

3. The actual processing classes can be moved to different assemblies easily. The factory is the only class that would needed to be updated.

In the next post I'll implement some more filters and look at how reflection can be used to provide some more customizable capabilities.

The psychology of software development....

2008-12-18T05:32:00.003-06:00

I'm going to get back to my series on the factory class soon, but there was something on my mind yesterday that I wanted to post here. Before I start, I'd like to ask a couple of questions:

Have you ever sat in front of you computer, wracking your brain to solve a problem, then have the solution just come to you later when you are doing something totally unrelated to programming?

Have you ever been close to a project deadline and found yourself being totally unproductive because you can't stay focused?

Software development is an amazing pursuit. It requires knowledge, but at its core it requires creativity. Most non-developers don't understand that a developer can have the same relationship with an application that a songwriter has with a song.

The human mind is an amazing thing, as someone who uses their mind as a means of income, I suggest that you be attentive to how your mind works and when you are productive and when you are not.

I know that my experience is not the same as everyone, all of our minds work differently, but this has been my experience.

If I am dealing with a difficult problem, I'll work on it until I realize that I'm not going to find the answer quickly. At that point, if I walk away, and do something that I enjoy, the answer will just 'come to me'. My theory is that the mind keeps working on the problem even though you are consciously working on it, when it finds the answer, it will notify you.

There is tremendous power in explaining the problem to someone else. Find another developer that has time to listen to you. Start explaining the problem to them, most of the time, the process of explaining it to someone else will help you find the issue. My theory: by vocalizing the problem, you move the problem to a different part of the brain that might have a better chance at solving it.

Realistic deadlines motivate, unrealistic deadlines kill productivity. Software development requires creativity. Creativity requires that you be relaxed. Deadlines obviously have to be set, but they have to be realistic. I have found myself many time fighting unrealistic deadlines. What tends to happen is that my mind tends to focus on the deadline instead of the software. Stress kills productivity, do what ever you can to stay relaxed.

Many times over the years, I've been in situations where deadlines were set based on business needs with no respect for the amount of work that needed to be done. Since software is basically invisible, folks that don't write software typically don't understand the amount of effort that it requires. Many times I've had clients give a 15 minute explanation of what they want and the ask "How long will it take?". When asked this question, I usually try to ask questions that help them related to the process of software development. My favorite is: "How long does it take to solve a crossword puzzle?" The answer is: "it depends on the puzzle". That's right, and there are usually puzzles in an application that you can't completely understand until you get into it.

Just a few notes from an old code dog...

Google Webmaster Tools....

2008-12-16T17:56:00.002-06:00

I spent most of the day today working with Google's web master tools. I've used them before, but they have been expanded greatly. I whipped up a quick program to search a website development directory and generate a google compatible site map (using the factory pattern of course)

I'll probably post the code at some point, I have some ideas on how to improve it. If you have a site, and want to be able to generate a sitemap for it quickly, give me a call.

If you are a webmaster and want to see what the webmaster tools can do for you, go to Google Webmaster Tools.

The Factory Pattern in Action....

2008-12-12T04:02:00.027-06:00

In my opinion, the factory pattern is a powerful mechanism for processing data. The cool thing about it is that you can break a complex process down into small manageable pieces. Those pieces can then be applied interchangeably to create a flexible powerful process.

One of my own personal interests for years has image processing. I've been taking photographs since I was a kid. Now that photographs are digital instead of chemical, it presents some really interesting possibilities for the analytical side of the brain.

I've been toying with the idea of creating an automated image processing program for years, I actually had a pretty cool version of it working a few years ago, but I've never been able to polish it up enough to make a product out of it. What I can do though, is write about what I was working on. It may give other people some ideas or teach someone something cool about the .NET framework.

Professional imaging programs like Photoshop and Fireworks provide a "batch" mode where you can determine a set of operations to perform on a group of images. This is very useful feature for webmasters. But how would you design something like that if you needed to go beyond the operations that those programs provide?

My plan was to break any possible operation on an image (resizing, convert to black and white, lighten/darken etc.) into a single object. Each operation would have a common method that performed its operation. The "Process" method would accept an image as a parameter and return the processed image when it was done.

Once a collection of these objects was built, they could be mixed and matched into an image processing "pipeline" that could do some pretty amazing stuff on a large group of images.

Here is an ideal base class for the image processing pipeline....



using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.Serialization;

namespace ccg.imaging
{
  
  [Serializable]
  public class IdealImageProcessBase
  {  
    public virtual Bitmap Process(System.Drawing.Bitmap bitmapin)
    {
      return bitmapin;   
    }        
  }
}

Reality quickly sets in
This "do nothing" base class for image processing is simple and works, however, in reality it needs some work.

The problem is, when you are dealing with images, you are dealing with large volumes of data. The System.Drawing.Imaging namespace provides a ton of very powerful features for manipulating images, but at some point, it may be necessary to manipulate the image 1 pixel at a time. The System.Drawing.Bitmap object provides the GetPixel() and SetPixel() methods for doing this, but, being managed code, they get very slow when processing large images.

Take A Walk On The Wild Side
Back in the day before C had anything after it, nothing was 'safe'. Before the days of managed code, you could easily write code that stepped all over itself. The hallmark of the C language was its speed. C was a language with no boundaries, direct manipulation of memory locations provided a tremendous amount of speed and flexibility...and danger. It was very easy to write code that had unintended results, I won't bore you with the details, just suffice it to say that operations as simple as concatenation of strings presented a lot of danger to your application.

Managed code provides a lot of safety for your applications, but the trade off is a lot of overhead. Thankfully, you can still get down to processing memory directly, but it requires some special security privileges and object locking.

Here is my real-world image processing base class...



using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.Serialization;
using System.Security;

namespace ccg.imaging
{
  /// 
  /// This is a base class to provide low level image 
  /// processing services for different
  /// filters and image processors.
  /// 

  /// 
  [Serializable]
  public class ImageProcessBase
   {
  
   protected static bool _allowunsafe;
   protected static bool _permissionchecked = false;

   #region Bitmap Locking and Unlocking

   //--- locks the bitmaps data bits so that we can access them more speedily
   protected System.Drawing.Imaging.BitmapData LockBits(Bitmap b)
     {
     // GDI+ still lies to us - the return format is BGR, NOT RGB. 
     return b.LockBits(new Rectangle(0, 0, b.Width, b.Height),
                       ImageLockMode.ReadWrite, 
                       PixelFormat.Format24bppRgb);    
     }

   protected virtual void UnlockBits(Bitmap b, BitmapData bmd)
     {
     b.UnlockBits(bmd);
     }

   #endregion

   public ImageProcessBase()
     { 
     if (!_permissionchecked)
       {
       _permissionchecked = true;
       try 
         {    
         System.Security.Permissions.SecurityPermission perm = 
                   new System.Security.Permissions.SecurityPermission(
                  System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode);
         _allowunsafe = true;
         } 
       catch 
         {
         _allowunsafe = false;
         }
     }
  }
  
  public virtual Bitmap Process(System.Drawing.Bitmap bitmapin)
    {   
    if (_allowunsafe)
      return ProcessUnsafe(bitmapin);
    else
      return ProcessSafe(bitmapin);   
    }

  protected virtual Bitmap ProcessUnsafe(Bitmap bitmapin)
    {
    return ProcessSafe(bitmapin);
    }

  protected virtual Bitmap ProcessSafe(Bitmap bitmapin)
    {
    return bitmapin;
    }


  [DataAttribute(DataAttributeType.Hidden)]
  public string FilterName
    {
    get
     {  
     Type t = this.GetType();
     object [] attrs = t.GetCustomAttributes(true);
     if (attrs != null)
       {
       foreach(object attr in attrs)
         if (attr is NameAttribute)
           return ((NameAttribute)attr).Value;     
       }
     return t.Name;
     }
    }

  [DataAttribute(DataAttributeType.Hidden)]
  public string FilterDescription
    {      
    get
      {  
      Type t = this.GetType();
      object [] attrs = t.GetCustomAttributes(true);
      if (attrs != null)
        {
        foreach(object attr in attrs)
          if (attr is DescriptionAttribute)
            return ((DescriptionAttribute)attr).Value;     
        }
      return t.Name;
      }    
    }  
}

Now the first ImageProcessor object checks to see if unmanaged code is allowed. By making the _permissionchecked and _allowunsafe properties static, we know that this will only be checked once. The Process() method uses the _allowunsafe property to determine whether or not to call the ProcessUnsafe() method. Since the default implementation of ProcessUnsafe() is to call ProcessSafe(), objects are not required to have an unsafe implementation. The base class provides the methods to Lock and Unlock the bitmap object for unsafe processing and also provides some attribute properties to provide information to the GUI.

All of this will lead to Factory Pattern, I promise, this is just the initial base class implementation. The next installment will cover the implementation of a couple of real processor classes and possibly the factory...

Recommendations....

2008-12-08T11:47:00.002-06:00

Many times employers and clients want to see recommendations when they are considering hiring a new employee or contractor. If I have done a project for you, or we have worked together, I would appreciate any glowing compliments that you might have about our time together.

My Favorite Pattern....

2008-12-06T07:58:00.003-06:00

In my first post to this blog I mentioned that you are unlikely to find any ground breaking software ideas. My target audience is the beginning to intermediate programmer that is learning coding and design. I stand by that, that is the spirit with which this is written.

Several years ago, the "Gang of Four" came out with their book "Design Patterns: Elements of Reusable Object-Oriented Software". Much to my chagrin, I've never read the book cover to cover. I have resorted to reading interpretations by others. To be honest, I've only used a few of their patterns in real life. The Factory Method Pattern, however, is one that I find myself using over and over. There is a ton of information available on the net about it. There is nothing new here, but this is my contribution to the reader on how I use it.

The factory method pattern allows multiple similar objects to be created and used by the application, without the application having to know a lot of the details of what the objects are doing. In my opinion, one of the keys to writing a good maintainable application is to remove as much detail as possible from the top level code. The details need to be "hidden" in lower level objects. The trouble with this idea however is that you create many small objects that do similar yet different functions. These objects need to be able to share commonly needed functionality while being able to add their own distinct functionality. This is where the factory method pattern excels.

Here are a few real world examples that I've implemented lately:

An application needs to be able to generate several reports. Each report has its own set of parameters that it needs. Some reports require a specific date, while others need a date range for example. There is a common UI used to provide the parameters for the report, once the needed data is provided, each report does it's own thing in generating the output.

A food broker needs to be able to communicate with multiple external entities (manufacturers, distributors, customers etc.) via EDI. The EDI format is standard, and like all standards, everybody has their own version of it. The application needs to communicate with all external entities using their version of the "standard".

A company that hosts conferences needs to be able to update a Microsoft Dynamics CRM database on site during the conference. They have a custom application that uses bar codes to identify attendees that need to be updated. Several different types of business entities need to be updated. The workstations that the attendees visit communicates with a common server and send transactions depending on the update needed. The server needs to identify the transaction and send the correct update to Dynamics CRM.

Enter the factory method pattern...

The factory method pattern allows several similar yet different classes to be created easily. Each class can share common code (placed in the base abstract class) but has the ability to modify the functionality to meet its individual needs. The factory class is responsible for identifying the needed concrete object and creating it. The controlling code can then use the created object as needed without knowing the specific class that has been created.

In the report example listed above, the base class contains needed UI support routines as well as an abstract GenerateReport() method. Each concrete implementation can override the UI routines as needed as well as implementing the needed report generation. The factory creates the concrete report object based on the user's selection. The controlling code interrogates the created object to find out what parameters are needed and shows or hides input controls based on the information needed. Once the parameters for the report are provided, the GenerateReport() method is called to create the final output.

The EDI example may be obvious, the abstract base class contains common EDI functionality, the concrete classes implement each entities version of the standard. The factory determines who we are talking to and generates the appropriate class. The differences in formats is completely hidden from the controlling application.

In the Microsoft Dynamics CRM example, the server receives a transaction from a workstation, the factory determines what type of concrete class is needed, the concrete class implement the logic needed to update the appropriate type, the abstract class provides support logic needed by all concrete classes.

So what are the benefits of doing things this way? Here are a few off the top of my head:

1. The top level code doesn't contain the detail of what is begin updated and how. The logic at the top level is minimal, understandable and maintainable.

2. For each detailed concrete class, the code required is minimal. If you design the base abstract class well, then you will find that each concrete class contains very little code, only the code required to implement the differences will appear.

Ok, I have to come up with some shortcomings of the pattern...

Hmmm....well, I guess some folks my struggle with inheritance, however, if you are going to be a successful developer using object oriented languages you will need to become very familiar with that. You especially need to be very familiar with some of the qualifiers like public, protected, static and abstract. I love the static keyword, it means very different things depending on where its used.

Documentation is key. It is difficult to look at the code and determine what is going on unless you are familiar with the specific technique. Learn UML, a picture is worth a thousand words goes for documentation as well. Assume that the person coming behind you to maintain your code is a beginner. You will thank me one day because if you stay in this business long enough, there will come a time when you look at your own code and say "What was I thinking?"

Window Class Name Is Not Valid....

2008-12-04T13:53:00.002-06:00

I have a Windows Forms application that I wrote several years ago (my first production C# application actually) that occasionally throws an exception when it starts. The Error message says "Window Class Name Is Not Valid" and it happens when the startup code tries to show the main form.

I did some searching around and found that there are several people that have encountered the same error. In my case, it only happened when I tried to debug the program. It used to happen once, and then I would retry running the program and it would work correctly. I hit the wall though, this time it happened every time I executed the application.

I read this fairly lengthy thread about the problem. The solution that worked for me was turning off the Visual Studio Hosting Process.

Right click on the project that is giving you trouble, select properties, select the Debug tab. The Visual Studio Hosting Process selection is a check box at the end of the list. When I unchecked it, my project would debug every time.

Ch....Ch....Ch.....Changes

2008-09-15T06:11:00.002-05:00

Beginning October 1, 2008 Cedar City Group, LLC is closing as a business entity. I (Donnie Hall) will continue to do consulting, however, I am currently working primarily through Sysgenix Resources. I continue to support some of my existing clients.

If you have troubleshooting, or some small development projects of any type, please call me and I will help you or find someone that can.

I'm not going away, just changing the way that things are being done.

Thank you,

Donnie

Email Hosting Changeover

2008-02-01T20:20:00.000-06:00

On Saturday February 2nd, our email hosting is to change to a new hosting provider. This change over will require you to take action to make this transition smooth.

If you did not change your password and it does not contain between 7 and 64 characters and include 1 upper case letter and 1 lower case letter. Then you will need to change your password when you login.

In addition, you will need to modify your account settings if you read your email through a client such as Outlook. The following document provides instructions modifying the password and changing your email client.

Email Change Over Instructions

If after attempting to perform these procedures, you are still unable please call 1.888.277.9320 for technical support.

Cool quote....

2007-12-19T08:16:00.000-06:00

I saw this quote yesterday...it applies to software development and many other areas of life..

Talent hits a target no one else can hit, genius hits a target that no one else can see.

Happy coding....

A long time requirement finally met...

2007-12-17T19:57:00.001-06:00

As long as I can remember, I have felt that when you use a text box to perform data entry for a database column, that the maxlength of the text box should match the definition of the column in the database. And that it should automatically change on the text box if the database design changed. I never had the gumption to actually write the code to do that, but I've always felt that it should be done.

I'm sitting here working on a fairly simple data entry form for a web application, I'm populating a text box with the value from a SubSonic field and that old urge to set the max length kicked in. I dug around in the SubSonic object model for a little bit and came up with the following code.

txtFirstName.Text = buyer.FirstName;
txtFirstName.MaxLength = buyer.GetSchema().GetColumn("firstname").MaxLength;

as my buddy Tim says Schweet!

Abstraction...

2007-12-14T06:10:00.000-06:00

In my original post to this blog, I mentioned who the audience is. If you are an experienced developer that has it all figured out, then I'm not going to post anything here that you don't already know. However, if you are a beginner to intermediate level programmer, I hope that I can give some advice that will be helpful to you.

I've been posting about Subsonic for a while, but the question is: Why is a tool like subsonic important? The key point here is abstraction. This is a key principle in software development that has been around for years and years. It's important. At the application level, you must learn to think abstractly (I'm setting the date of birth for an employees vs. I'm updating the dob column in the employee database). The mind can only deal with so much detail, thinking abstractly helps you solve bigger problems. Object oriented programming helps in this quest.

Datasets are objects too....
Well, yeah they are, but not the kind of objects that I'm talking about here. Datasets do not provide abstraction. Think about this, when you deal with an application that is dataset oriented, what is the documentation that you refer to most often? Could it be the database schema? Your column names appear at the top level of your code. There is no abstraction. With true business objects, the top level appication has no idea how the objects are stored, the application deals with operations like, Save, Update, Delete. Much more abstract.

The problem with business objects
The downside of writing business object oriented code has always been the overhead. Business object oriented code has always taken a lot of time because of the code needed to 'translate' between the object model and the database model. Datasets seem to be quicker because there doesn't need to be any translation code. In the end, however, dataset oriented applications become brittle because they are tied to the database in an unhealthy way. What about strong typing? With datasets you must constantly typecast your data. The business object model provides strong typing which by definition improves your code.

If the abstraction argument doesn't work...
If the concept of abstraction doesn't appeal to you, then how about this. If you use true business objects, you have intellisense at the application level, even when databinding to controls.

The reason Subsonic is important....
Subsonic provides the needed abstraction while removing the overhead of writing the translation code yourself. The concept of abstraction is what is important, not the specific tool.

I'll get off of the SubSonic Kick.....

2007-12-14T05:47:00.000-06:00

At some point but not right now.

Yesterday, I was posting some recent web site changes to a test site. For the last couple of projects that I've worked on, I've had access to SQLCompare which is a darn good product. I have encouraged several companies to buy it, though I don't have a copy of my own. Anyway, I had a bunch of database changes to make, no SQLCompare to synchronize, what do you do?

Subsonic to the rescue. With a few rules to follow, Subsonic provides a cool mechanism for upgrading your database. Subcommander provides a /version option which will create two scripts. One script will create the schema for the configured database, the other will create a script that will recreate the data. Pretty cool stuff. I 'versioned' the new database and the destination database. Run the new schema script on the destination db, then run the destination data script to re-insert the data.

Obviously, there are some rules here: you can't delete columns, or tables (without modifying the data script). But this provides a cool mechanism for developers.

How many times have you need to duplicate a database for development purposes? You want a development, testing and production version of your database. You can use backup/restore to create a new database but this provides a quick mechanism for duplicating that is very easy to understand.

There are many uses for this utility, creating your initial install scripts, version control of schema (and data!) also, though I've not checked this out yet, but a poor man's SQL Compare could be created with the combination of SubSonic and a text comparison tool like csdiff.

Pretty cool stuff, Thanks guys.

Subsonic Rocks

2007-12-13T06:18:00.000-06:00

Ok, I've been talking about Subsonic for a little bit. I'm working on a project now where I'm really starting to put it through its paces. I have to say that the more I work with it, the more impressed I am.

I must admit that I got sucked in by the scaffolding approach. You drop one control on a form and poof you have a data entry application. Well..almost. I was writing a form to do some simple content management. I didn't want the content to appear on the front list. With the scaffold control, it appears that you get everything. There is also a quicktable control which provides more control, but as soon as you need to add any logic to the process (hey I need to hash the password instead of storing it in clear text) at that point you are writing your own form.

On the plus side, writing your own form is much easier with Subsonic than without it. Subsonic plus partial classes in c# very easily solve the dilemma of customizing code that is generated. Typically, I need a method that retrieves an object by something other than the primary key. I typically let subsonic generate code for me into a separate data layer project. The subsonic code goes into a folder called 'generated'. I then create a second folder called 'Custom' at the same level. Any time I need to add a method to a subsonic class, I create a partial class in custom that has the same namespace and class name as the subsonic code, and add the method that I need. My new method appears on the objects as if subsonic created it. If I need to regenerate the subsonic code, my custom code remains in tact. Pretty cool stuff.

How things have changed....

2007-12-04T06:08:00.000-06:00

I downloaded the Visual Studio 2008 (3.3G) and can't help but think about the first compiler that I used as a professional developer. I was so excited when we got it....Turbo Pascal 4. As far as I know, it was one of the first languages to use the IDE approach. Anyway, it arrived on 2 5.25" floppies one floppy was nothing but samples.

SubSonic, the best thing since crunchy peanut butter

2007-12-02T13:06:00.000-06:00

My first introduction to the MVC way of doing things was via SubSonic. The project that I was working on at the time was suffering from death by n-tier. One of the worst things that could happen while working on the project was to realize that you needed a new piece of data from the database. We were going by the book so here are the steps we had to go through:

Write a stored procedure to access the tables.

Write the code in the dataaccess layer to call the stored procedure (thank goodness we were using the Enterprise Library which simplified that code)

Write a business layer routine to call the data access layer

Death by n-tier. I guess if the business layer added any value, I could understand it, but it didn't.

I was introduced to SubSonic. SubSonic is a data layer generator that implements the ActiveRecord pattern. In a nutshell, it automatically generates the code to present your application with strongly typed data objects and collections based on your database design. It can operate in two modes: mode one automatically updates the code datlayer code for you at compile time using their build provider. This is cool, becuase you can update your database and the changes are automatically refelected in your code the next time you compile.

I prefer mode 2 where Subsonic generates code for you and places it into a separate data layer project. You have to go through some extra steps, but this method just feels better to me. This mode is also recommended if you are going to be deploying to a shared host.

SubSonic also provides a Scaffolding control that can help you prototype your data input logic quickly.

I'm by no means an expert on this stuff. But SubSonic seems like a good tool to have in your tool box.

My approach to MVC...

2007-11-27T06:17:00.001-06:00

Over the holiday, in addition to several other tasks, I decided to develop my approach to the upcoming release of Microsoft's MVC framework. From what I've learned so far, MVC is definitely the way to go. After studying MVC, web forms looks like a kludgy mess. MVC is clean and cool.

Anyway, my problem is that I have several sites that could use some revamping. I want to use MVC but what do you do? Microsoft's frame work isn't available. Monorail is out and stable but will it be used going forward? I studied several approaches, including writing web forms in a more MVC like manner.

I've decided to use monorail for my upcoming projects. I am certain that there will be a simple upgrade path to Microsoft's MVC if necessary. Monorail gets me on the way with my upcoming projects.

What to do?

2007-11-22T03:55:00.000-06:00

As I've mentioned, I've been studying monorail and the whole MVC architecture. I am excited about it. Can't wait to get started with it, however, I was a little disappointed to see this post from the leader of monorail indicating their wait and see attitude towards Microsoft's MVC framework. I'm ready to go, ready to get started. MVC seems to solve a lot of problems that have held me up for years. But, what do you do? Investing a lot of time in learning and implementing monorail seems like it may lead to a dead-end. I began learning the brail view engine, but Hammett indicates that it doesn't work with MVC. Will it by the time its released? Does anyone else have an opinion on what we can do now?