Pete On Software

RSS Feed

Archive for 'Rant'

A Dearth of Mid-Level Developers

My company is having a very difficult time finding mid-level developers. Our development team isn’t that large, so the number of junior people we can support isn’t that large. In terms of .Net experience, we have 3 relatively junior developers and myself. I’ve done a fair amount of architect work, senior development / team lead stuff, and been doing .Net for about as long as it has been out. That leaves us with a gaping “talent hole” that could be filled by a mid-level developer or two.

The problem, however, is that every resume we see is someone who is definitely very junior or someone claiming to be an architect (who often techs out at lower mid-level). My boss (and I can’t say I blame him) is against hiring someone who thinks too highly of himself and seems unteachable. A certain amount of ego does come with the territory and everyone is trying to get the best job for the most money possible, but people really need to be honest with themselves.

I’ve done a lot of thinking about this and I think that I’ve come to a conclusion on this problem. The reason that we are having such a hard time finding solid mid-level developers is because they are actually very scarce (in relation to the rest of the populace). Hear me out.

Junior developers are – of course – the most plentiful. Every developer who will ever be anything starts out in this rank. However, I believe that the people who will actually become great in this profession move out of this group rather quickly. In talent level, they are my coveted mid-level developers; by experience, they can easily be overlooked as still junior.

Almost two years ago, Jeff Atwood wrote a post on Coding Horror in which he quoted Bill Gates on this subject. I’ll leave you to read the post, but basically someone asked Bill Gates if accumulating experience made programming easier and he said, “No. I think after the first three or four years, it’s pretty cast in concrete whether you’re a good programmer or not”. He goes on from there, but that hits my point.

People who “get it” and have a lot of experience – the “rock stars” that Joel Spolsky writes about – are hard to find. Spolsky claims that you don’t find them easily at all because they are rarely on the market for any amount of time and in essence “hand pick” their jobs.

People who “get it” and don’t have a lot of experience – probably most likely the people I am looking for – are very hard to find because their resumes hide the fact that they are good and are going to be awesome some day.

People who don’t “get it” can have any number of years of experience and they are still not attractive candidates. In the Columbus, Ohio market (where I’m located) there is a relative shortage of developers, so seemingly everyone can find a job. What I’m speculating is that these individuals end up with 7-8 years of experience and think that they should then be able to land a senior job. In my opinion, however, they fall into the category of “poor developer” and shouldn’t be hired into those positions by any reputable company. What may happen is that some consulting firm will pick them up and bill them out at $150.00 an hour as “experts”, but it is really the consulting company’s system that gets them through projects.

(A quick note: I am not saying that anyone who consults is no good. I’ve met several consultants who are of the utmost quality and deserve every penny they make (often they are independent and actually get to keep much of what they bill). However, I’ve also met quite a few consultants who I’d mark as falling into the broad categorization of this post.)

I don’t know what to do about this problem, actually. If you are a good, solid developer who “gets it” and wants to work with the latest and greatest coming out of Redmond, leave me a comment and if we still have positions open at the time, I will personally make sure that your resume gets looked at and unless it is god-awful, I can pretty much guarantee you a phone tech-screening. From there its all you, hotshot.

Sql Reference Tables

Reference Book Image from http://www.sxc.hu/photo/1022436
Disclaimer: Personally, I prefer to use uniqueidentifier as my primary key data type. It cuts down on improper joins (similar looking values aren’t in every table, ie 1, 2, 3) and is infinitely portable among environments. I think the extra space and overhead is worth it.

We have some reference tables in our database at work. This itself isn’t abnormal, everyone has these. What made these tables special was that the IDENTITY Primary Key for the table started at 0. At first I thought that this was awesome. I know it is a debate for another day, but I love that my arrays, counters, etc start at 0 in C#. I know it may not be necessary anymore or whatever, but it comforts me, okay? 🙂

Things soon changed for the worse when I realized that 0 being a significant data value was a problem. “Why?”, you may ask. Well, when you just generically “new up” an int, what is the default value? That’s right, 0. So, if someone doesn’t set a property when trying to identify some reference value, in a 1-based table (or a GUID one) you will get an error because that isn’t a valid value. However, in a 0-based table, that “forgetfulness” will match right up with a value and go in no questions asked. You can’t validate it, because 0 is perfectly fine to have.

Lesson Learned: Zeroes are fine for arrays and loops, but keep them out of reference tables!

Y Kant Developers Read?

Bookshelf image from flickr.com/photos/ianturton/2341264331/
I guess there are two major reasons that developers don’t read many books. This is kind of a timely subject for me right now on both fronts.

First, I began a new job at the beginning of last month. My new employer was running a Visual Fox Pro environment and wants to move to a full-blown .Net SOA Architecture. I was brought in to architect that. The team that I have (save one programmer that I recommended and was hired) are all Visual Fox Pro 6 developers who don’t know a stitch of .Net. With the exception of one guy (who I *really* appreciate), none of them seem to be very interested in reading books to find the answers to problems or to learn the gist of C# and ASP.Net.

This was also the case at my last job. With the exception of the guy who I recommended at my new place, no one would read books. They would take them at our insistence and then never read them. Someone once told me that developers read about one technical book a year on average. I couldn’t believe it when I heard it, but I’m starting to wonder if that number isn’t smaller. The first major reason just seems to be laziness and/or apathy.

The second major reason seems to be the driving force behind Jeff Atwood and Joel Spolsky‘s new venture, StackOverflow. According to Joel, “Programmers seem to have stopped reading books. The market for books on programming topics is minuscule compared to the number of working programmers. Instead, they happily program away, using trial-and-error. When they can’t figure something out, they type a question into Google.”

I believe that to certainly be true, and for people who are using new technologies or are on the bleeding edge, trial-and-error is the only way to go. However, if we are talking about anything that is approaching a year old, books certainly exist. My problem with trial-and-error and Google is that you never really *learn* anything. You are kind of limited to your own cleverness.

Advanced books not only teach you new features, they teach you new techniques. If you just trial-and-error, you will only try to figure out the Python way to do your C# code, or the Ruby way to do what you’ve always done in Java. You won’t learn what there is to learn about the new languages and the cultural mindset that comes with them. You could skip reading books and read lots and lots of source code, but I don’t believe a majority of developers are doing that, either.

However, so far we’ve only talked about learning a new programming language or technology. There is no way to effectively trial-and-error the kind of knowledge that you get from books like Code Complete, Pragmatic Programmer, GOF Design Patterns, or Practical Cryptography. How in the world has this style of learning, proven effective for centuries, fallen so far by the wayside? I am not trying to seem terribly elite, but I really read more than an entire technical book per month on average, along with several technical magazines and journals. I directly attribute my success in my field to that fact. Why can’t people see books as an avenue to their greater success?

  Recent Entries »