Setting up my work computer

Yesterday I set up my work computer, which had its hard drive finally replaced after the crash. The good news was that the data in the D: drive was rescued (unfortunately, that was the less important data for me, because I had recently made a backup). I started with already installed Windows XP and MS Office plus the essential development tools for my current project VS.NET 2003 and SQL Server 2000.

In the following five hours I installed (after downloading the latest version if necessary) about 40 tools (I was somewhat conservative, heh) . Setting Firefox with about 10 extensions, installing 7 essential VS.NET addins, tweaking numerous options of Windows XP, VS.NET and of a bunch of other programs.

But after a good deal of installation and customizations I realized that I was working in another profile, used by our sys-admin. Fortunately, I always tend install programs for all user of the computer, so this was not a big problem. A manual moving of a few customizations files from one profile to the other worked quite OK and interestingly nothing messed up. Nearly everything went smooth except setting up the MS Outlook account, which took me about half an hour to figure out the right way to do it. But apparently I got it wrong since there are no longer items in my Inbox when now I connect with the web access to our Exchange server.

Touch typing (week 6 overview)

This week I couldn’t beat my personal best of 280 CPM, but I decreased my error rate significantly. My first attempt on putting accuracy as a higher priority than speed gave me 277 CPM with 4.8% error rate which is apparently more effective than 280 CPM with 10.5% error rate. It is remarkable that such a little shift of attention gave such unexpected results. I continued to practice accuracy and scored 255 CPM with 4.1% error rate and 225 CPM with 3.1%. I definitely have to improve on this. It actually felt pretty hard to keep focus on accuracy when for 5 weeks I had concentrated solely on speed. When I get bored and anxious of errors I unconsciously tend to increase my speed.

It is interesting to try to estimate how error rate affects the effectiveness of typing. There are several factors that need to be considered. The most important is the demand for accuracy. When chatting, for example, speed solely is equal to effectiveness, but for any other type of writing, accuracy is a must. But when I type in MS Word, some of my errors get corrected on the fly (i.e. “whehter” is fixed to “whether”) without me even noticing, which decreases the importance of making errors.

Some writings also require a revision in which I can fix the mistakes along of making other improvements like rewording or elaborating my ideas. On the other hand password input is an example of typing requiring accuracy. But though in theory I can always go back and correct my mistakes after I am finished with the initial typing, in practice I usually spot my errors very soon (often immediately after I hit the wrong key) and I tend to Backspace and retype in order to get it fixed right away. That means that if I am making a lot of mistakes, my effective typing rate is greatly affected by my error rate. Probably one percent error rate results in at least 3-5 percent decrease of gross efficiency, since one has to switch to correction mode and interrupt his flow.

Another thing I realized is how important keyboard position is. Studies show that the keyboard should better be lower than your elbows and wrists so that you don’t have strains. Also the keyboard should have a negative slope so that your fingers can move more easily to the numeric keys and the functional keys. My keyboard at home was laying above my elbows so I had to put a pillow on which I can sit in order to deal with this problem. I tried it and I no longer feel a tension or tiredness after a long period of typing. Try it yourself, you will see a difference!

Catching Up With Audio Content

Last week I had the chance to catch up with some great audio content. Recommended listening:

• Hansel Minutes - Scott Hanselman is one my favourite bloggers and his 3 audio shows were great listening too.
• Johanna Rothman: Moving Towards Agile Project Management - Johanna is definitely one of the notable woman in the industry and she does another great presentation
  
• Adam Cogan on DotNetRocks - This is a must hear. Adam is the most active contributor to the comprehensive SSW Rules to Better...
• Shawn Wildermuth on Decomposing ADO.NET (again on DotNetRocks) - entertaining conversation about various .NET and other projects Shawn have participated in
• Chad Fowler interview on Perlcast.com - Interesting talk about outsourcing and on software development in India

Using Computers Painlessly and Productively

Being a computer user for a pretty long time and probably for much more time to come, I am becoming interestingly interested in how to make my computer interaction maximally enjoyable and productive. Since I have been training to become a fast typist for the last six week (or at least to learn the QWERTY keyboard by heart so skip the hunt and peck searching of keys), a logical accompanying step for me is to use the mouse less often, and use the keyboard instead. Everyone has been saying that you can’t be much productive being a clicker, and they are right.

In the last 6 months I have becoming increasingly fond of keyboard shortcuts, starting with VS.NET 2003 shortcuts, then learning more of the Windows XP shortcuts and some of the MS Office shortcuts. If you are already a power user of any tool you better do yourself the favor of learning the shortcuts. As I blogged about few weeks ago I also use three tools for fast launching programs and documents. Well, sometimes this might gets confusing, remembering such magic keys. I often hit F5 instead of F9 in MS Outlook as if I want not to check mail, but to compile it, heh.

Another thing I have not given enough attention is ergonomics (this is a whole new science). Being about 8 hours a day in front of the computer, surely, affects various aspects of my body. There are numerous examples of people having developed pains due to bad habits when using the computer. I found a great very comprehensive resource that tells you what these problems are and how to avoid them. It has lot of links to additional information in case you want to dig deeper in any specific area.

My own experience is that I have difficulties doing simple proven healthy things like resting my eyes regularly and doing exercises each hour or less. I tried to remind myself to do it by using a cool program called Workrave, but after awhile I conditioned myself to ignore it. And I uninstalled it when it became an annoyance rather than a helper. I have tried other tools as well but they worked for even less time, and I think a way for such a program to be more effective is to be adaptive and change its ways of attracting your attention. On the other hand I often prefer not to be distracted in the middle of something I do. There are not many occasions when one really is in the flow and it is very ineffective to get interrupted.

I am now thinking of some other way, instead of a distracting, to get a tool that just records my behavior in front of the computer. I can then analyze its log and figure out when I take breaks and how much time I spent on a task. The tool has to be able to let me start and stop task recording very quickly. I have not succeeded to find the right tool for the job yet, but I can extend one sample program that I found in the Coding4fun articles. Its simple and that’s what I need but I don’t see why you have to start and stop tasks. At any moment of your day you are doing something. It is OK to have activities like “taking a break” and “watching the wall dumbly”. Hmm, and an important requirement is that the current activity should be always visible on the screen so maybe a toolbar in the system tray is the best place to put it. Oh, I can imagine so many handy features for such a tool, but the focus should be on simplicity.

Targeting .NET 1.1 in VS.NET 2005

Last week I have been struggling with the strange idea of mine to use VS.NET 2005 with  a project that should target .NET 1.1. To make a long story short it didn’t go smooth. I had especially huge troubles with strongly typed datasets. During the conversion a bunch of new files got added, and now there are all these .xsc, .xsd, .xsx files. I can’t view and edit my .xsd in simple XML. I had to manually add the generated .cs file to the solution in order to have them built in the assembly (probably a problem with the MSBuild target for .NET 1.1 I found). So if you are thinking to continue targeting only .NET 1.1, I don’t recommend using VS.NET 2005 unless you have plenty of time to fight your way thorough it.

Managing Dependencies Instead of Avoiding Them

Jeff Atwood has blogged about Avoiding Dependencies and links there to an old article by Joel Spolsky, defending the Not-Invented-Here Syndrome. I think that Joel has made his point well. He emphasizes on “If it's a core business function -- do it yourself, no matter what.” But I cannot agree with all of what Jeff is saying (and that’s not just because I am one of those developers “trolling downloads and experimenting with every tool listed on The Daily Grind”, ha-ha).

It is just a matter of trustworthiness. I trust in most things Microsoft produces, but I also trust on many of the third party software vendors – many of them have proven that their quality is superb. I also trust in many open source projects. You just don’t have to dive in them blindly, but you should develop evaluation skills and start with looking not only the current state but also predicting the future of the project. I can fairly quickly decide if a library looks reliable by looking at its code and by searching what other people say about it (well, I confess I have been tricked about a POP3/MIME component recently).

But Jeff talks here not about OSS, but rather about commercial third party tools where you can be overwhelmed with licensing problems and patches. There is definitely a cost of getting those right, but IMHO the benefits are often greater.

Let’s say that you are developing a desktop app that has to look professional. I really don’t think you can do it in a reasonable amount of time with the standard WinForms controls. They were pretty primitive in .NET 1.1 and have slightly improved in .NET 2.0 (there are some very nice new ones). But no wonder there are hundreds of third party replacements of the classical DataGrid. I have used a DataGrid in a real app and had to dig into Google just to complete somewhat trivial tasks. In my next project I had used third party controls which where very nice and required little or no coding for my part. Well, they have a learning curve and had some quirks here and there, but I find this acceptable. Since I have never written complex UI controls myself, I am sure that I would have spent months trying to get things the way I wanted them and the GUI would have been very hard to tweak and improve on later stages. And if you write business apps like me, your core competencies should include deciding wisely what dependencies to choose and how to manage them well. I often wonder if my coding is mostly making components and libraries play together nicely, but actually there is a lot more than it.

Even if one of your dependencies fails you consistently and you can get it fixed, you can replace any time with your self-made solution or another vendor’s. It will not be always easy but it won’t be impossible either. Just ensure that you have have covered your code with tests and that you have isolated dependencies in a way that makes it easy to drop them anytime.

Jeff also gave the MSFT Patterns as example of a giant, complex frameworks. And probably he is right that the Enterprise Library should be used on truly enterprise solutions, where it will pay off. The downside in using it is that you have to learn a lot. You have to get good in discovering functionality and the right way to use APIs. Another potential downside is that the next version may have breaking changes, but that pretty much sums the negatives. But while using it, you learn about good design and that will definitely pay off in the long run. You will also end up with a code that will be easily extendable, because this library is designed by pretty smart people and surely it has some desirable qualities such as orthogonality and extensibility. Actually in my current project we considered using it, but we didn’t find enough reasons to do so, and I think this was the right decision. The only problematic area in which we struggled a bit was our data access layer code, which was a legacy from another system. We should have started clean and do it by probably using the ideas and code by the Data Access Block. But I got some refactoring practice and I feel great about it.

OK, I am going very much off topic, so if I have to sum it: Manage dependencies wisely instead of avoiding them.

P.S. You may also like to read Jon Galloway on the topic.

God Damn Exception

Heh, accidently in a batch file instead of printing the names of several hundreds files, I opened them. I have (.sql) extension associated to Notepad++, (which is a great replacement of Notepad). Of course the OS has some limits for the number of open files, so I got a dialog with  title “int exception” and the nice message ”God Damn Exception -1”.

I like that kind of messages! In my previous company a developer put errors in a dialog titled “грешка човешка” which in English sounds something like „error of a human”. He just didn’t specify if the human was the user or the programmer!

Playing with TSQL

We keep all our TSQL setup code in a VSS generally on a statement per file basis. This includes code for creating stored procedures, user-defined functions, views, and some data initialization scripts for nomenclature tables and other immutable data. The standard stored procs are auto generated using the database schema thanks to CodeSmith, and we also auto-generate triggers to fill audit tables.

The DB generation process looks pretty straightforward, with the exception of figuring in what order to issues CREATE statements, since some of the stored procedures and user functions have dependencies on others. We have used until now a pretty simplistic solution, where we manually set some kind of order for the calling the CREATE statements. The files that contain TSQL using dependencies have a numerical prefix that determines when they should be called. This is definitely feels a bit strange, because you have to think of some unique, somewhat random number to prefix the file, but so far this has worked. An obvious better way to handle it is to store directly the relationships which file depends on which other files. So let’s see what I can come up with:

• Brute force solution – issue the commands in any order and reissue those that fail until they pass (or until N unsuccessful attempts are made). Ha, I bet this would work quite well in practice, but it’s somewhat hacky.


• Manual dependency declaration – for each TSQL file with dependencies, have a file with (.dep) extension, listing the files it depends on. Then it should be fairly easy to issue the commands to osql in the proper order.


• Automatic dependencies extraction – it should be possible to find automatically for a stored procs and user-defined functions the entities on which they depend. If those entites are already in the DB, I think that’s quite easy - I had stumbled upon an article describing how to do it. But when you are working simply with text files, this gets harder. The TSQL code should be parsed and the entities identified. A simple regex might work in some cases but it will have quirks (we should have in mind that the entities might be also table and views). But since in our DB we use a strict naming convention for our entities it should be easy for us. Just search for ones having cp_ or cf_ prefix. I wonder how hard it will be to build a more general solution. Then we will definitely need a powerful TSQL parser. I found an SQL parser, which was once free and now is commercial, but unfortunately when it was free it didn’t support TSQL specific things like stored procedures. I think a good way to write such a parser is by using ANTLR and generate probably C# code (some people are doing this).  I couldn’t find other resources on the web, and this seems strange, I can see a lot of scenarios where such an SQL parser will be useful.

Touch typing (week 5 overview)

I hit 280 CPM yesterday which is close to my original 300 CPM target for the week. When I type consistently with 300 CPM and less than 5% errors I will be more than satisfied with my results. Last Sunday I had an interesting session where I decreased my error rates in 9 consecutive 5-minute typing sessions. I started from 13.9 and reached 8.9, but that is still far from my target. I finished practicing on the article The New Methodology which was a very good reading. But I decided that there is no real value in translating it as I mentioned last week – the Bulgarians interested in agile methods surely know English well enough.

One thing I noticed is that when I concentrate my attention to my fingers rather than the text, my results tend to improve. As if I am thinking with my fingers ( I also realized that the position of the hands is very important. You get tired after awhile if your fingers don’t rest on the home keys. The way I touch the keys still varies, I can’t yet settle on a method, that is somehow the best. Sometimes energetic big movements feel right, but if I want to be really fast I probably have to make the least amount of effort possible and keep my fingers as immobile as possible. When I make unnecessary movements, that shows that my goals are confusing. Probably that’s why my error rate is so high, I keep hitting keys because of guessing, while I should be knowing their right position by now. I guess, with a bit more practice I will finally persuade myself that I know perfectly the keys and will get more flow in typing. At rare occasions my fingers just fly over the keyboard as if that’s the most natural thing for them.

Computer Misfortunes

On Wednesday I had the misfortune my hard disk of my work computer blowing up. It didn’t crash instantly, though. First I got some corrupted files and directories warnings that told me to run chkdsk. And when I decided to listen to them chkdsk fixed the errors by removing a lot of indexes and files that resulted in failure to start my Windows XP. The OS install disk didn’t not help and the hard disk made strange sounds. Later it was verified that it had died.

I was lucky though that no significant work was lost – the VSS database is on our server. I thought that I even have not lost my personal files, because a month ago I made a full backup at my home machine hard-drive, but now I can’t find my old documents. I verified that in the .BAT file that I used for replication, there was xcopy command for those documents, but now I can’t find the destination folder at my home machine. Argh! Hopefully the most important items I have online while mailing them to some people or to myself.

Since there is currently no available substitute machine at the office with the software I use in my day-to-day activities, yesterday I worked from home. Well, it was not exactly efficient work, because it proved that to set up the perfect development environment was not that easy. I actually have VS.NET 2005 at home (got a free license on the Launch Day in November), and the project targets .NET Framework 1.1, so I played a lot with the conversion and trying this workaround for the build. It worked with at least one project, but I did something wrong while editing project files by hand, messed up one project badly and had to start all over again. At least I get more experience with VS.NET 2005, but I think I like VS.NET 2003 + the right addins better.

Today I also worked from home, but it was not a productive day either. First thing I realized I had to do was to make a full DVD backup of my projects and other stuff and I burned 6 DVDs in a row. I also used the occasion to reorganize my data, so that when my work comp gets ready I can just copy the data from the DVDs and get started. When I was finished with this operation, I fired up the IDE. It appeared that my SourceSafe installation was messed up. I reinstalled it but VS.NET said that the source control provider is corrupt.

OK, if I could not get working on the code, at least I should be able to set up the DB. I saw that I had a copy of the MSDE instance that I used, so I tried somehow to use it with SQL Server 2005. I could not, so I decided to install MSDE and see if I can do something with it. I refreshed my memory about its installation parameters and created a new instance with it. Then I realized that what I had was not a copy of the instance, but a copy of the desktop engine, which was perfectly useless. Oh, gee, that’s too much for a Friday. I hope that the new week will start more positively.

The silver lining:Actually there is something good about my hard-disk failure – I will start with a fresh OS and not have my start menu hide my desktop completely ( I had not reinstalled for a whole year and my machine was overloaded with a lot of unused programs. I now believe that each 6 or 12 months I should reinstall to keep my system healthy. And I might want to do complete backups at least one a month.

Comparing Datasets

If you have been working with ADO.NET datasets probably you have needed at some point to compare two datasets to see if they are different and how they are different. I was writing some unit tests and I wanted to make sure that a dataset has not changed after the operation. So I first cloned the dataset and after completing the calculations, I had to compare the initial copy with the possibly modified original.

The simplest think I thought of was to export both of them to XML and to compare the result with Assert.AreEqual(...). Well, the funny thing is that the first time I did it, the call failed because of whitespace differences. OK, I googled for a quick workaround. I knew about the free MS XML Diff, but I didn't want to use an external program for this silly thing.

Then I found XmlUnit for .NET which has a method called XmlAssertion.AssertXmlIdentical(...) that seemed appropriate. I added the reference, made the call and it appeared that the assembly could not find NUnit assemblies. I had to recompile the dozen of C# files and there was a NAnt build configuration along with them. Unfortunately I couldn't get the NAnt compile target working right away though I think I supplied the correct parameters. I realized that probably XmlUnit is also an overkill, so I began to search for other possibilities.

And not long after, I realized I could use Merge() and HasChanges() to find if something has changed. I should have thought of that earlier, but while it is good for detecting that anything has changed, there is a way to get changes. For more detailed differences I guess I could use GetChanges() and process those in some appropriate way.

The moral of the story: When you get tired and weary of finding complex solution to simple problems, then you open yourself to more simple solutions :)

Working Effectively with Legacy Code - Book Review

Finally I have finished reading Working Effectively with Legacy Code by Michael Feathers. I should have completed it a lot earlier but the weeks around the New Year were more appropriate for other types of reading and activities. This is a hell of a book, and if you are working currently on some legacy code, you will definitely get a breath of fresh air if you read it.

I have been working with legacy code for about two months and initially I was quite frustrated since I was mostly used to do greenfield development. I tried to apply the same approach that I am usually using when cranking fresh code, but numerous times I just broke the code though I was increasingly careful.

The single most important thing that I learned from the book is that if you put safety first (and in real-world preserving the existing behaviour of the code is always a top priority), the best way to deal with legacy code is to put it into a test-harness and use TDD to add new features. In reality putting code under test is rarely easy, unless it was developed that way (and wont feel like legacy). It might be design issues, terrible dependencies and whole lot more, but the author succeeds to describe numerous alternatives to tackle all these kinds of problems.

When you alter code, do it in small steps, so that each mechanical change has a single purpose. It is often very tempting to do two or three steps at once if you can envision where you want to get, but you should resist it (I often cant, but I am working on my habits J ). First you make the smallest steps possible that you can to put the code under test. You first use dependency breaking techniques (there is a list of about 25 of them in the third part of the book), then you write the tests and after that you can start with the real refactoring. Sometimes you have to do things that you wont normally do, but keep in mind that this is just a temporary step towards taming the legacy code.

I just scratched on the myriads of ideas and techniques that are in the book. You can read more reviews by Roy Osherove, Eric Gunnerson, Hristo Deshev, but you better get the book anyway. And I have to repeat what Robert Martin says in the forward:

"Before you get too excited, I warn you; reversing rot is not easy, and it's not quick. The techniques, patterns, and tools that Michael presents in this book are effective, but they take work, time, endurance, and care."

Touch typing (week 4 overview)

I reached 250 CPM milestone this week as expected, but after that for a few days my results were in the 240 range. Yesterday night, after returning from a party at about 3:30 am, I realized I missed my daily training so I launched Stamina. For my astonishment I reached 254 CPM with just 10.5% error rate on my first attempt.

For the end of the next week I am targeting 300 CPM though with my current progress rate this seems a bit over optimistic. I hope I will make a quantum leap soon in decreasing my error rate. I guess I do something wrong – probably my attention is wandering or my fingers are not moving in an effective way or something else. I have to discover it and nail it down. I know two pretty fast typists – one was piano player and the other one accordion player. Probably this helped them to get to speed for far less time than me, but surely this is not an excuse for me to stop training.

In order to keep my interest in speed typing, I decided to do something more meaningful instead of typing the default phrases of Stamina. Well, they are sometimes entertaining but sometimes not very useful. Today I tried the feature of exercising with an external text and I put in the recently updated Martin Fowler’s article The New Methodology. I realized I can type even without thinking about the text I see, but why not combine the typing with some pleasant and beneficial reading. I actually think of translating this article in Bulgarian (it is already available in 8 languages). Its size is about 20 pages, so it will take me a week if I do 3 pages a day. This will be also a typing practice with in a real-world situation. Hmm, let’s do it!

Legacy code is amazing

Legacy code doesn’t stop to amaze me (sometimes even my code makes me wonder what was I thinking when I wrote it). Ayende Rahien had recently put up an excellent list of 25 good things about legacy code. I don’t think my experience covers all of this goodness but I can see his point.

In the past week I have been working on a various pieces of code but predominately reworking a form that was initially 6000 LOC. Some of its methods where with absurd cyclomatic complexity, length and somewhat illogical organization. I succeeded to pull some of the logic in separate classes and put them under tests but some of the functions are so entwined that it seems nearly impossible to get control over them. Even if that is the case I strive to improve the readability of the code and after a series of small safe refactorings with Resharper in most of the code I reached the point when reading the code made sense without stopping at each line to analyze it. This, of course, lead to revealing some subtle bugs.

I sometimes wonder what is more cruicial for the code – to be readable or to be covered by tests. Apparently, both are important, but if you really have to choose a priority, what would it be? I think readable, well organized code is much easier to achieve. It requires just a bit of discipline and common sense, so I vote for this option. Just the habit of naming things appropriately is a very powerful technique and I wonder why so many developers are in love with short highly encoded names of variables and functions.

I have seen also a tendency to keep the number of classes to a minimum and to add various responsibilities to existing classes until they become unmanageable. No, there is no limit of classes that the IDE supports. Just when some new functionality doesn’t fit in the existing classes find how to incorporate it in the code base, see the big picture. You may have to change some existing things that worked, but it can’t be any other way. When a system is only just patched and patched and patched sooner or later it becomes so unmentionable that you can’t hold in your head all its peculiarities. The moral: write good code and free some mental RAM for the person who’s reading it and maintaining it.

Balancing Agility and Discipline - Book Review

Balancing Agility and Discipline: A Guide for the Perplexed by Barry Boehm and Richard Turner is a great book if you want to get clear on whether agile and plan-driven methodologies are a better fit for your project and how to find the right balance between the two extremes. As usual the theme "no silver bullets" is present, but the valuable thing is that the authors use enough real world data and case studies to prove their points. There share their thoughts about the types of risks in different projects and what kind of methodology can address them better.

There is a brief introduction in various agile and plan driven methods and a comparison between them. Well, we sometimes tend prefer freedom from choice, but you may think of methodologies just as tools in your toolbox for solving problems. Though many developers and managers have their preference of work-style, you should not dismiss other more possibilities when appropriate. One thing I got interested in while reading the book is PSP and TSP (Watts S. Humphrey is the man behind those abbreviations). I should check those ones, and especially PSP.

I can't sum up everything in a paragraph or two. There are good reviews of the book by Ron Jeffries and Darrell Norton. Its forward is by Grady Booch, Alistair Cockburn and Arthur Pyster and you can get a good sense about what the book is about from their words. Recommended reading!

Touch typing (week 3 overview)

I am continuing my series of typing lessons logs (start, first week, second week). Last week I had some problems trying to keep up with my goal: beating my record every single day. The first days of the new year started fine with the results of 208, 213 and 222 CPM (the last one close – just few minutes before the end of the day (). But then I reached a plateau for two days in a row, coming somewhat close to my 222 record, but never going over it. It was rather frustrating experience trying for 30 minutes in the late evening to unsuccessfully beat the target score, but I couldn’t expect everything to go perfectly. I actually anticipated a such a temporary setback and was prepared not to get discouraged ( Then yesterday I reached 231 and today I hit 237 CPM, which is close to my first milestone of 250 CPM, (I heard that this was the minimum speed to be qualified for typing-intensive job in some national organizations around the world). My second future milestone is 300 CPM and if I could repeatedly type at that rate, I would be quite happy with the results of my endeavor.

So what I learned. First I observe myself that sometimes I get in the flow and type a whole sentence very fast with zero errors, but that happens just for a few seconds each session (if it happens at all). When I make a few errors in a row I have to slow down for awhile, otherwise I continue with high error rates and the frustration of not finding the right keys leads to more errors and slower speed. My error rate is still oscillating between 10.5% and 17.5%. One thing to note: in Stamina you can continue unless you type the right key. That is good for learning the keys, but not close to reality. To measure my skills yesterday I retook some tests at http://www.typingtest.com/. Actually I did very poorly, much worse than when I did when I was typing watching the keyboard. I found it hard to simultaneously watch the text, watch my typing and not watch the keyboard. Probably I need more practice with such types of tests, though the way errors are counted (that is on a word basis) is probably not very fair. I wonder how can I measure my speed more objectively.

Summary of the year 2005

I am a fen of all kinds of reports, so let me summarize the tech part of my life for the past 2005 below:

Work related activities

• The year 2005 was definitely .NET centric and my list of .NET resources was growing slowly but steadily along the way. After my first attempt to design a reusable Data Access Layer (it was based on attributes and sub-classing), I got in the ORM world. I got to know more about multithreading and numbers.


• I changed my job to work on an interesting .NET project. In its initial phase I had a chance to learn cool stuff like Enterprise Library (actually we decided not to use it). Wrestled with Excel Processing. Got to like Bugzilla. Wrestled with POP3 and MIME in a series of posts first, second, third, fourth. Ranted about GUI design. Wrote a postmortem when the project was done. In November the project was restarted and I have been doing some maintenance programming and it sometimes felt scary.


• Did an extensive MC++ and C++\CLI research before actually porting a small app from C++ to C# (it turned out to be one month of wasted effort, but I learned interesting things along the way).


• Did an ASP.NET project that I called BugTracktor as a skill acquisition and demonstration. My review on existing ASP.NET bug trackers got larkwared and my weblog visits increased 10 times for a week (just to drop to nearly the original level after that ()

Other technology related activities

• Became co-author of two chapters and a reviewer of 7 more for the Bulgarian .NET book. The first volume was released online for free and already sells as hardcopy.


• Started my thesis for my masters program. After thinking about some cool ideas, then thinking of some boring ones (, I stopped at Agile Metrics. Did some research on how to measure agility and investigated applicable literature and came up with some practical ideas and investigated free metrics tools for .NET code. Looked for Bulgarian resources on agility and after not finding many, translated some.


• Continued blogging throughout the year and reached more than 100 posts for 2005.

Notable Reading

• Read the excellent article Big Ball Of Mud and in later stages of my project it helped me get a clear sense about the status.


• Pragmatic Programmers Interviews at Artima and later I read the book


• Design: Documentation or Code – after reading a post by Martin Fowler and the classic essays by Jack W. Reeves I got clear on this topic


• Peopleware 2nd Edition – great book that Joel Spolsky recommends to be read at least once an year.


• Pragmatic Unit Testing – great book to point me that what I was doing most of the time was actually not unit testing, but just automated one.


• Halfway through Refactoring: Improving the Design of Existing Code and Working Effectively with Legacy Code – I better have a set of handy techniques by my side to put some scary code under control.

Notable Listening

• Kent Beck on Unit Testing and Johanna Rothman on Hiring Nerds


• Peli on MbUnit and Reflector addins


• Scott Ambler and Ken Schwaber on Agility


• DotNetRocks shows throughout the year and other podcasts


• Agile podcasts at http://www.softwareas.com/.


• Scott Hanselman on Code Generation

It was an interesting and productive year and I hope that the next one will be even better. Happy New Year!