Part 1 includes: 

1. A personal perspective on the Internet boom in the UK . 
2. A statement of the perceived problem.

1. A Personal Perspective
I was just 18 when the internet started to take off, and despite my college (High-School in the USA) having several well equipped computer labs for the time, there was only one modem in the entire building – and it was in the library. The internet was slow and wholly unimpressive.

By that point in my life I had already had commercial software released and I must admit, aside from a small passing interest my involvement with the Internet was small. Very small. At that point in my life I was coming to terms with the Commodore Amiga falling by the wayside and you would have been more likely to see me in the local pub on an evening rather than sitting at my obsolete machine. As a student, the last thing I could afford was a PC, and the Computer Labs – while open to me as a Computer Science student – didn’t allow you to do anything but MS-DOS based Turbo Pascal things or the use of M$ office. At this time I knew C inside out along with a good dose of MC68k assembler, and despite my protests they weren’t going to install VB, let alone C++ on their network.

Little changed at university, the extensive computer labs had intermittent and very slow internet access, I finally got to get my hands dirty with C++, although the OOP and design courses were dire. And web development at the institution was purely the province of Perl programmers. Java was a new thing and was only just beginning to pop it’s head over the parapet so it hadn’t yet made it into the course and M$ being M$, their software was no-where to be seen. This pretty much left developing for the internet a personal interest only pastime.

As such pretty much the first years of the internet hype revolution pretty much passed me by in a haze of a student social life mixed with subjects I already knew pretty much inside-out and trying hard to live on an excruciatingly low budget. Rent? Food? Or study materials?

I’m geek. I know it. I was programming computers when I was knee-high to a grasshopper. Ever since seeing that movie War Games that featured a computer called WOPR first reached the small screen, I wanted a computer.  Thankfully my youthful prayers were answered in the form of a hand-me-down Commodore Vic 20.  Remember those anyone?  And later after earning the cash doing a paper-round, a Commodore Amiga 500. 

In short I’m trying to say that I’m a computer enthusiast who is lucky enough to see work as a chance to flex the wings of my deep seated interest and hobby.  I suppose in a way I am one of the lucky ones. I was exposed to computers at a very low level from the outset and as such I know how they tick. 
Which is more than I can say for many of my industry peers around my age and younger.  Those with similar exposure to me have in my opinion a distinct advantage. 

2. A Statement of the Perceived Problem

Many of the developers in the UK in the first decade of their career (and some in their second) do not fully understand the technology they use.  This is not to say that everyone is in this position because I have worked (and indeed work) with individuals who are very good at what they do, but alas I have found them to be in the minority. 

They tend to be the ones that were like me, interested at an early age.  Or maybe they were thrown in at the deep end with an exceptionally technical project and managed to swim instead of sink, or those who found themselves in an environment where knowledge exchange from more experienced and knowledgeable team members was actively encouraged.  Unfortunately though, in the current UK political IT climate, many individuals are not fortunate enough to experience this. 

Another nail in coffin is the cost to business.  For an example in extremis, there are organisations out there (one I recently experienced) still NT4 entrenched and/or running creaky old legacy systems from the mid eighties, where forward thinking is actively discouraged and new technologies are seen with distinct and avid distrust.  After all, if it works, why fix it?  So there are many developers out there who haven’t had the opportunity to move on and out and those that finally pluck up the courage to move on are replaced with cheaper graduates, invariably creating a knowledge and experience deficit that can never seem to be resolved. 

Being a contractor for most of my career has given me a somewhat detached perspective to this.  Being interested as I am in the industry as a whole, being the sort of person who would rather learn a new innovation than play the latest and greatest computer game has allowed me to stay on top of the latest technologies.  It has also given me the chance to see many organisations of different sizes and shapes basically all repeating the same mistakes.  Undervaluing IT staff, and treating them as interchangeable assets, under funding area’s of business that the business relies on to do business and conversely allowing behemothic IT departments bully the rest of the business into what suites them and while this may sound wonderful, in practice these are the departments full of legacy equipment with a ‘path of least resistance’ philosophy.

Business is a big player in all of this.  But then, so are the employees.  It’s a sad and regrettable fact that too many people in the UK IT industry regard business funded training as the only way that they would consider learning something new.  In a climate of actively promised industry training that hardly ever materialises this is a horrible perspective to maintain.  Indeed several candidates I have interviewed in my career for roles have admitted when questioned that even though new technologies are readily available, they haven’t pursued them because their employers wouldn’t pay for it.  In my book that’s an instant disqualification!  But this attitude is rife!  So many are simply happy with the status quo and they sit comfortable in their own world doing their utmost to maintain it.

Non more so than with the role of ‘Web Developer’.

I and many of the individuals I have worked with in recent years are the left over’s from the internet boom years (yes, I am one of them).  We were employed in the high times or in the aftermath that still pervades straight out of university to create websites using ASP, PHP and scripting technologies of their ilk.  Knowledge of OOP wasn’t a requirement (most employers didn’t even know what it was!) nor about the underlying technologies in any great detail. 

My very first role in the industry was as an ‘ASP Developer’, and all my employer needed to know was that I had a vague knowledge of the 4 SQL statements, a basic understanding of VBScript and I could write some HTML.  The combination of these technologies even then was a massive step down for me, but I needed to eat so I took the role.  This decision was more out of desperation than I would have liked as there were few other IT roles at the time. So there I was spending my first year essentially being a drag and drop monkey programmer as my employer churned out one website after another and charging extortionate amounts.  I got to tinker with VB COM objects occasionally where a little extra performance was required, however this was very rare. 

When the dotcom bubble burst, so did my employer. My co-workers and I would turn up to work each day as requested and some weeks there was nothing to do. Slowly the staff slunk away either because there was no more work or they got made redundant. Eventually even one of the directors found another job. In the end it was just the MD and me – until the MD sold the remains of the company. Of the entire company only I was employed by the new owners, but only for a limited time. I hope as a small testament to my ability, although in reality being the newest junior programmer it was probably because I was the cheapest.

My story and the story of so many others, is not unique. Many have not moved on from the collapse. So many companies even now still only use ASP and PHP, though this is becoming less of an issue to some extent as Microsoft based companies are moving out into .NET and some of the others are choosing to head the way of Java. Microsoft being aware of this is seemingly attempting to further dumb-down ASP.NET under the guise of productivity in an attempt to make the transition easier, much to the chagrin of many a more skilled developer. The simple truth is that moving from the ASP/VB procedural "object aware" cludge paradigm to the ASP.NET OOP/Event driven paradigm is not an easy transition once you move below the superficial facade on the face of ASP.NET. I've been bought in almost too many times to count on projects going into the toilet because the development team did not understand what it was getting itself into and because the business didn't understand the true cost of the transition.

I am one of the lucky ones. I understood OOD and associated patterns early, even though I must admit the exact names of some of the more abstract GoF designs and those derived from them eluded me (come to think of it one or two of them still do until I need it...). I had had the opportunity in the earlier days of my life to play around with opcodes (MC68k assembler), Just In Time technologies and other abstract things such as event driven models (the Amiga had one great big event driven OS that multitasked better than XP does now!). Very, very few people have had that chance.

The problem is this, and it comes in several parts:

• Lack of individual opportunity and motivation to improve
• Lack of knowledge on the part of the developers and their employers
• Lack of a willingness to really invest in the future

And in the UK specifically, one driving thing:

• A saturated IT job market where loyalty is virtually non-existent and the employers just don't care.

[Here ends part 1]

If you are from the world of Java the term ‘Data Access Object’ is probably more familiar to you.  In J2EE they are considered best practice as the advantage of using DAOs is that any business/domain objects that contains operation specific logic do not need to be aware of the actual physical data implementation of the system.  Thus, if any changes are made to the data sources layers they shouldn’t affect the (usually) more complicated business/domain logic.  They are also exceptionally useful for enforcing rules on the data and how it is to be used in general. 

Some developers consider DAOs and ORMs a different paradigm, however I have yet to see a convincing argument to say that they are substantially different fundamentally and the differences seem to stem from marketing convenience and personal choice than any real semantic difference. 

In this area .NET has a little catching up to do, although there are plenty of implementations available on the web (including a .NET port of the Java Hibernate tool).  However despite this many firms prefer to either create their own or bodge something together that invariably ties the project to a specific data source. 

History

Recognising this rather early in 2002 I decided to step back and write an implementation to fit the requirements of a personal project, but that I would be able to evolve over time.  I developed the original with the help of a friend of mine (Andy “Smellyhippy” Jump) in my personal time and he and I went on to successfully implement it into an EPOS system and then a later into a CMS before Andy moved on and I continued with various other systems for clients as my contracts came and went.  A cut down version of the largest and most complicated revision known as BATS (used in a CMS system) is currently in use by a UK utilities firm.  A version of “BATSLite” (butchered to avoid copyright issues) will be available soon for completeness on this page; I am currently trying to ensure that the code fully works despite several items specific to the client being removed. 

A New Breed

When the new year came around a few individuals came to me asking if a newer less ‘hacked’ version would be made available.  After some conversation I decided that it was about time that a re-write was due and set about re-creating the core.  The result of which is ‘DATS2’.

DATS2 *is* another BATS implementation; however I felt that the rename was essential for various reasons (including legal ones).  It represents a complete re-write, restructure and departure from the quirks that have over time made their way into the BATS code set.  The implementation as it currently stands is also somewhat specific to the requirements of the individuals who came to me requesting the change; as such this version more or less represents the first ‘revision’ so to speak.  (More accurately I made it work to a basic level and handed it over). 

So I am releasing the current version to the public domain.  I may create a sourceforge place for it in the coming months as revisions from the few individuals already in possession of the code add and revise it.  Please feel free to do the same!  This version represents the cleanest and rawest condition I have ever released DATS and it’s predecessors in and I hope this benefits the project.  There is currently no documentation, for which I can only apologise, yet I hope that over time this situation will be rectified. 

Oh... one more small thing, due to the requirements of those who essentially commissioned this work, the supplied (incomplete) DAL generates the SQL queries in a JIT fashion.  This was due to limitations on their behalf and nothing to do with my own choice.  I am planning a CLR stored procedure implementation of the DAL for use with SQL2005 and a WebService DAL in the future - depends on what comes up though...

DATS2.zip

Future Implementation Thoughts

1. Add associated objects functionality.
   This would allow you to associate other DATS based objects to a DATS object.  This is something I have been thinking about for a while as part of BATS and there have been instances where this would have been an exceptionally useful feature.
    
2. Create a Facade system to allow for smoother Object Oriented implementations.
   The 'object-relational impedance mismatch' problem is a nasty issue that everyone seems to dislike and a solution is certainly required.  An easy way out includes some thoughts bouncing around in my head to help this somewhat.  
    
   Other proposed solutions include the Nordic O/R dbms model (see the article in Architecture Journal 8), which while seems like a good solution, involves a lot of work for the everyday programmer whenever a new object needs to be created... the lack of Multiple Inheritance in .NET also makes this issue sizeable.  DATS has always aimed to reduce the the amount of code needed to be written by the developer so the Nordic model is out for DATS.  Another issue is that the Nordic model requires an underlying RDBS - which also flies in the face of the DATS philosophy of detachment from underlying data implementations.
    
   Suggestions on this are most welcome...

BATSLite

Until I can make BATSLite available, here is the class diagram.  Notice the complexity difference.

For 'spaz99'

Sometimes as you may already know, custom controls can become somewhat large. With many features and abilities that need to be configured as part of their usual operation, usually this is done via the use of custom attributes. However this does get unwieldy on the larger objects.

M$ not being altogether immune from practicality catered for this with ASP.NET by providing the [PersistenceMode(PersistenceMode.InnerProperty)] attribute.  This allows us to move sizeable attributes to inner XML based elements instead, while being able to retain the properties in our objects.

An example of which is given below.

namespace InnerPropControlExample
{
    using System.Collections;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Web.UI;
    using System.Web.UI.WebControls;
       
    [ToolboxData(@"<{0}:InnerPropControl runat=""server"">        
    <Parameters>
        <Param Name=""param1"" Value=""value1"" />
        <Param Name=""param2"" Value=""value2"" />
        <Param Name=""param3"" Value=""value3"" />
    </Parameters>
</{0}:InnerPropControl>")]
    public class InnerPropControl : WebControl
    {
        /// <summary>
        /// Holds the parameters during object lifetime
        /// </summary>
        private ParamCollection _par;

        /// <summary>
        /// Gets or sets the parameters.
        /// </summary>
        /// <value>The parameters.</value>
        /// MRW: 21/02/2007 
        [Browsable(false)]
        public ParamCollection Parameters
        {
            set { this._par = value; }
            get { return this._par; }
        }

        /// <summary>
        /// Renders the control to the specified HTML writer.
        ///   -- In this case it simply renders out the name/value parameers
        /// </summary>
        /// <param name="writer">The HtmlTextWriter that receives the content.</param>
        protected override void Render(HtmlTextWriter writer)
        {
            foreach( Param par in this._par )
                writer.Write("{0} = {1}<br/>\n", par.Name, par.Value);

            base.Render(writer);
        }
    }

    /// <summary>
    /// A basic Name/Value container
    /// </summary>
    [PersistenceMode(PersistenceMode.InnerProperty)]
    public class Param
    {
        public string Name;
        public string Value;
    }

    /// <summary>
    /// A collection for the Name/Value container
    /// </summary>
    [PersistenceMode(PersistenceMode.InnerProperty)]
    public class ParamCollection : IList<Param>
    {
        private List<Param> _col = new List<Param>();

        /// <summary>
        /// Sets the parameters as they are added by ASP.NET
        /// </summary>
        /// <value>The param.</value>
        public Param Param
        {
            set { this._col.Add(value); } // notice the Add!
        }

        // Everything below is pretty much standard...

        Param IList<Param>.this[int index]
        {
            get { return this._col[index]; }
            set { this._col[index] = value; }
        }
        int IList<Param>.IndexOf(Param item)
        {
            return this._col.IndexOf(item);
        }
        void IList<Param>.Insert(int index, Param item)
        {
            this._col.Insert(index, item);
        }
        void IList<Param>.RemoveAt(int index)
        {
            this._col.RemoveAt(index);
        }
        void ICollection<Param>.Add(Param item)
        {
            this._col.Add(item);
        }
        void ICollection<Param>.Clear()
        {
            this._col.Clear();
        }
        bool ICollection<Param>.Contains(Param item)
        {
            return this._col.Contains(item);
        }
        void ICollection<Param>.CopyTo(Param[] array, int arrayIndex)
        {
            this._col.CopyTo(array, arrayIndex);
        }
        int ICollection<Param>.Count
        {
            get { return this._col.Count; }
        }
        bool ICollection<Param>.IsReadOnly
        {
            get { return false; }
        }
        bool ICollection<Param>.Remove(Param item)
        {
            return this._col.Remove(item);
        }
        public IEnumerator<Param> GetEnumerator()
        {
            return this._col.GetEnumerator();
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this._col.GetEnumerator();
        }
    }
}