How Not to Implement a Data Layer

If you are creating a new application with a clean slate, please don’t do what a developer I had first hand experience with did. This is the sort of material I would expect to find on the daily WTF!

Warning! Coding Horror follows. Don’t do this!

1) Ridicule code generation saying it won’t work, and that no one is using it anywhere. Reject the fact that several industry luminaries with great architectural experience have designed excellent code generated frameworks. Don’t generate anything. Do it all by cut and paste. Write your stored procedures by hand, despite the fact that 90% of them have a similar structure.
2) Design and implement your own less than optimal scheme for a data access layer and business logic layer, despite the fact that a quick internet search and a few hours reading would quickly show you the gaps in your knowledge. When I say less than optimal, what exactly do I mean? How about using reflection between your data access and business logic layer! Oh and while you’re at it, for good measure create your own non industry standard nomenclature, just to make it more confusing.
3) Ignore advice on inheriting from BindingList instead of List; plus completely ignore the fact that you probably will want to implement an event driven model for your object classes.
4) Create Load methods that can take different types of keys (think table primary key and rowids in Oracle). Pass one type of identifier to some methods, and the alternative to others.
5) When challenged to justify your design decisions say you did it that way in C++!
6) I could continue, but I think you get the idea…

You should definitely consider one of the many good tools already available for generating DALs and BLL stubs. Several are free, such as CSLA by Rockford Lhotka (buy the book, it’s a sound investment), MyGen, NetTiers 2.0 (although you will probably need to buy CodeSmith). Others require you to part with money such as the (IMO, poorly named) LLBLGEN Pro which has a stack of ORM features, and Wilson OR Mapper to name but a few.

I’ve spoken to one or two people recently who were amazed that someone with 10+ years of experience could do something like this, which is the reason I decided to post. It all comes back to Ego. The better programmers are usually the ones with the smallest egos. OK, I feel better having got that off my chest!

Speaking of Digital Natives…

Kathy Sierra recently posted a simply brilliant article on the subject of modern learning. I think this quote from Jason Fried sums up my belief:

“Hire curious people. Even if they don’t have the exact skill set you want,
curious, passionate people can learn anything.”

On Certifications, Learning and the ACS

Rob Farley’s series of blog posts (How they know you know , What’s wrong with IT?, On Learning) raise some excellent questions on how we could provide accurate and representative certifications in software development. Does the software development industry need a regulatory body? This is something the ACS has tried and so far failed to do, though I suspect they are doing this from a political motivation rather from a position of industry consensus.

  • Do certifications matter? It depends!
  • Do certifications prove you can do a specific job? It depends!
  • Would certifications with logged hours prove you can do a specific job? Definitely!

Rob provides an analogy with the health industry but I think this is more like gaining your pilot’s license. You have to log a certain number of flying hours i.e. actual ‘on the job’ experience, recorded and logged and audited. Trainee surgeons perform minor surgery under the watchful eye of their mentors, and as their experience increases they perform increasingly complex and lengthy procedures. Trainee pilots fly dual control planes with their mentor in order to log sufficient flying hours (a friend with a pilot’s license assures me that PC flight simulators really do help you learn to fly!). So perhaps this is what the software industry is lacking. No one wants you flying a plane solo or whipping out an appendix if you don’t know what you are doing! But is the topic too broad and changing too quickly? Should we just favour people you have the ability to learn quickly, are enthusiastic and have the ability to get the job done?

Can you regulate and accreditise the software development Industry? Is the ACS the body to do it? I personally think that the single most important factor in making the IT industry, and particularly the software development side of it, almost impossible to regulate is its breadth and rate of change. By the time anyone writes a comprehensive accreditation (including books, exams and the information filters through to university courses etc) it has often been revised, sometimes dramatically so.

The very malleable and black box nature of software renders it unsuitable for the same metrics or ergonomics we apply to other more tangible things. Take for instance, designing an entirely new interface to a process: with no ‘yard’ stick other than experience, it is hard to define a ‘good’ (or even ‘good enough’) interface. [This is where the Zen like “Be your own client” is useful]. It is not something that is easily taught; rather it needs to be experienced. Rather like the important role of making mistakes and learning by them. There are schools of thought that believe making mistakes are a fundamental part of the learning process.

I think a positive way forward is for a company such as Microsoft to bring out developer certifications in ‘a new’ sandbox format that truly measure ‘ingrained’ skills as oppose to ‘swotted’ facts. Microsoft has already made moves in this direction. A software certification that is guaranteed to prove you can do a range of things would be much more like law or accountancy exams. Exams which are heavily multiple choice orientated are always going to spawn so called brain dumps, which can be rote learned. Now there is nothing essentially wrong with rote learning; after all that’s how we all learn to speak! The problem is that the number of questions can never be large enough to be a representative test, unless you were asking hundreds, if not thousands of questions, which of course is impractical.

A number of the leading practioneers in our industry are self taught programmers. OK, I have no hard statistics, but I do know at least half of the high profile names in our industry are self taught programmers, and that’s not to say they don’t have a university education in Computer Science or some other subject. It’s just that they taught themselves before attending a degree course.

Consider the fact that most managers have no relevant qualification or certification to show they can perform their role well (and let’s face it, many can’t). This is no different from a programmer. Do we expect managers to have certifications in management? Hmmm, maybe we should…

I think Mitch Denny and Rob Farley made some excellent observations but I think they may have missed something when they talk about the digital native. The biggest problem digital natives face is not that they dislike learning or being taught, it’s that they do not like being held back in the rate of learning; education is set up to run at a pace slightly above (and one would hope above not below) the ‘class average’ and that syllabuses, teaching methods and rate, reflect this. If you are passionately interested in any topic, learning it will not seem like a chore and the rate of learning and retention is much higher.

The ACS has tried to be more relevant but does not seem to be succeeding (I won’t mention the pin-up calendar affair, nor that they are conspicuously silent in the blogosphere!). Maybe new, recruits like Rob can have a significant impact and I truly hope so; but deep down I’m a cynic and I believe they won’t make a substantial difference in the near term. Many people who have become involved with the ACS have commented on its heavy bureaucracy, and like politics, many people get involved eager to change things but slowly get absorbed by the existing command structure.

I’m not adverse to the ACS or other societies such as the ACM and IEEE (I have been a member of both), nor am I adverse to the ACS attempting to be a catalyst for change in the industry (hell, I might even join for a year!), I just don’t think they are going about it in the right way.
I felt encouraged reading Rob’s account of the ACS’s mentoring scheme, which sounds like a great idea and probably worth the membership fee alone, if the program is any good; it’s only downside appears to be that it is effectively a ‘closed-shop’, so it’s not possible to say whether or not it’s particularly relevant. I believe the best thing the ACS could do to show that it is the right body for the software development industry, is to make it’s mentoring program more open and maybe even open it to non-members with the view that if it is good then people will join in order to have continued involvement in the mentoring program.

Personally, I’d love to have a mentor! I was about to say it’s probably too late for me but then I remembered this:

It is never too late to be what you might have been. – George Eliot

“Change favours the rich, the insider, the passionate and the downright lucky!” That’s enough raving from me…

UPDATE: Rob Farley let me know that the ACS mentoring scheme only applies to people in the Professional Development course run by the ACS. It doesn’t apply automatically to all members.

Calling VB.NET forms from VB6: Interop Forms Toolkit

Kathleen McGrath over at the The Visual Basic Team blog has released a short (approx. 6 minutes) screencast on the Microsoft Interop Forms Toolkit 1.0, showing how to create a Windows form in Visual Basic 2005 that you can call from your Visual Basic 6 applications.

The idea is that it enables you to incrementally enhance your VB6 applications utilising functionality in the .NET framework. Might be a good solution for someone supporting an existing VB6 application.

What is the most important phrase in software development?

I bet you’re thinking “It was on fire when I found it!” aren’t you? Well, that might be the second most useful phrase, but joking aside, I believe that this is the most useful:

Don’t take anything personally.

It encompasses all of the following traits of good programmers:

  • Being open to the ideas and opinions of others.
  • Being humble.
  • Not letting ego play a part in your thinking and decision making.
  • Not being affronted by other people’s suggestions.
  • A willingness to learn from others.

Early on in my career I will freely admit that I was guilty of not following this advice often enough.

I used to be an end brace man…

Don’t worry, I’m not about to burst into song (that would be unpleasant)!

Over the past two decades, I have shed most of my personal biases towards coding style. Where once I would have argued vehemently for a particular syntax just because I currently used it, I am now always happy to be shown a better or more logical way. I still believe that any coding convention should be backed by the reason it makes the code more readable, rather than just personal preference. When there is no benefit in one style over another, then personnal preference obviously comes into play.

But the one thing I can’t shed is the placement of curly braces in the C style languages (C/C++/C#). Now I’m not trying to ignite a holy war here.

For the first 3 or 4 years I programmed in C and C++, I positioned the curly braces like this:

if () {

}

But over time and exposure to many other languages (and many other programmers’ styles) I felt that it was unbalanced so I switched my style to

if ()

{

}

where I remain. To me, the semantics suggest Begin … End, so the second style seems more natural. This seems to be the default standard for the Visual Studio IDE. I had taken heart in the fact that the majority of the code I’ve seen coming out of Microsoft generation tools has followed this style, but to my horror I recently spotted generated code that follows “1st brace at the end of line”! After a bit of nosing around it seems it’s roughly 60/40. Even the .NET Framework Design Guidelines use the first style, despite the fact that Lance Hunt’s and other popular and freely downloadable coding guidelines specify the second.

One thing I don’t understand is why developers who adhere to the second style don’t write their methods the same way? i.e.

public int MyMethod(int x, int y) {

return h = x + y;

}

So all the C# coders who read this blog, please leave a comment indicating your preferred brace style. I’m curious, so don’t be shy!