Ivan Mitev In The Software Trenches

Summary of the year 2011

2011-12-31T18:05:00.000+02:00

I am continuing my series of annual retrospectives from 2010, 2008, 2007, 2006 and 2005...

There just a couple of things that probably deserve a brief mention about the year 2011:

I've been given recently a new role in the company I work for - to lead the development of one of our products. It's an interesting challenge. I am a bit reluctant to get overly specialized, since till now I've been contributed in a much broader scope, but there are obviously benefits of thinking and working in a more narrow context.
In the last month or so, I've been active in improving the company development process - mainly by assessing our current tools and practices and searching/evaluating others. It seems that we will soon transition to a better version control system (PlasticSCM). Also we might adopt various other tools to improve our productivity in different parts of the development process.
As the previous year, I continued to participate in our developers hiring process (helping with the job ads text, interviewing and assessing candidates). I think I am getting very good in guessing what are developer's abilities, pros and cons, just looking at a CV (though the candidate's code gives a much more precise picture).
Mid-year I've returned back for a couple of months to my old duties as a Support manager, but this was temporary. The next year, I don't expect to do much of this type of work.
Technology-wise, there were not that many novelties worth mentioning, besides me getting to know MS SQL Server much better. I participated in the endeavor of adding support for MSSQL for our applications (we supported only Oracle as a backend until this year). Learned a lot from this - the differences in the default locking models of Oracle/MSSQL were interesting. Although new technologies are now rarely introduced in our development, I am trying to keep up-to-date with everything interesting in our field. Besides the .NET related stuff, there are so many interesting things to follow, e.g. NoSQL. And of course, there's much more than the programming frameworks, libraries and tools, so a lot more to learn...

So this pretty much sums it all. Hope that the year 2012 would offer a lot of excitement and positive emotions.

On hiring entry-level/junior devs

2011-02-12T19:59:00.001+02:00

I was recently asked about my opinion on adding some young & not-experienced people to our dev team, and after I emailed my analysis, I decided the topic is worthy of a blog post.

I’ll first start with the possible disadvantages of hiring junior devs:

· Might be very ineffective compared to more experienced devs, due to lack of necessary knowledge, skills & habits. Of course, attitudes & motivation also affect productivity. Btw, productivity b/n developers might vary significantly.

· Might require significant time (usually the time of senior devs) to train them & supervise them continuously (especially in the first several months)

· More people equals increased time for communication & coordination.

NOTE: When I speak of skills, I guess I should be more specific. Here are a few categories of skills that would determine how effective a developer would be at his work:

· Programming skills – ability to write/understand/debug/modify code efficiently (those include skills working with tools like the IDE, the source control + basic skills like touch-typing)

· Problems solving and design skills – ability to analyze (and redefine) problems, to come up with several solutions and evaluate what’s the best, etc.

· Learning skills – how fast can he learn new things and adopt beneficial practices

· Communication skills – how well the developer expresses his ideas (via code/documentation/e-mails/verbal discussions etc) + how well does he cooperate with others from the team + how willing is he to ask for help when stuck

· “Get into the others shoes” skills – how well he can understand what the client needs + how well he understands how his work is affecting the work of the team.

· Leadership skills – those are probably not software-specific.

Though most young people have probably not had the time and the opportunity to develop those skills, there are still probably several advantages in hiring them:

· Easier to find on the market (and cheaper)

· Motivated and energetic (hopefully)

· Free of bad habits – developers with experience are more or less shaped by their experience, and might have accumulated many bad habits that they’ll need to unlearn. Newbies can be molded into good programmers, if given appropriate tasks, attention, training & feedback.

Conclusion

I have a feeling that the best mix is with predominantly senior devs and ~20% junior devs, but I’m sure that other combinations could work fine too.

Summary of the year 2010

2011-01-02T22:01:00.001+02:00

I somehow missed to write anything about 2009, but I am continuing my series from 2008, 2007, 2006 and 2005.

The most noteworthy change for me this year was my new role as support manager that I undertook for the last nine months of 2010. Initially the plan was just to substitute for a couple of months the person who recently got in charge of the customer support activities, but who had to go on-site to an important project. But I ended up doing this kind of a job for such an extended period of time. I was all the time trying to keep up with my work as developer as much as I can, though there were days when I couldn’t write code even for a minute.

It was a very different type of work. Definitely more stressful, especially in the begining. Unlike my dev work, it required often switching between tasks, quickly prioritizing where to put effort and where not. There were times I worked overtime by answering support tickets from home (before going to work or in non-working days), but the worse part is that often my mind continued to go back to the problems at work, even when I was trying to get rid of such thoughts.

The nature of this type of work was pretty demanding, as well:

It required deep and broad knowledge of many aspects of our products (I guess only a developer can have both).
It required knowing which of my colleagues to ask for assistance for particular customer issues (I admit I initially hated to delegate work that I though I would finish more quickly than anybody, but soon I realized that this is not always as effective as it seems).
It required an ability to quickly find out what is the customer really wanting and help him get it (either by directly solving his issue or thinking of clever workaround to get the job done in another way).

Often it felt very rewarding to help people solve their problems, and as an additional benefit my support work gave me a better understanding of how our products were getting used. This lead to better clarity what matters and what not, so I could concentrate on the truly important things.

Being the person responsible for the support, I strived to improve the process in several ways: by customizing the help desk software that we use, by educating our staff and our customers how to use it effectively, by trying to setup proper expectations and attitudes. There were numerous challenges and even several mini-crisis during those nine months. They definitely gave me a better understanding of the bigger picture. They also shaped my vision how things should be done in order to things to go smoothly. It was a valuable experience, but I am happy that I will be handing it back to my colleague, since I think that I would be more valuable in other areas of the product development. My passion for being a developer is stiill strong, but additionally I think I’m a person whose understanding of the product, the technlogies and the customer needs, could be used for architecting proper solutions for the areas that will make a difference for the company and its customers.

Besides this role of the support manager, there were other experiences that were new to me:

Going on a two-week on-site project – I went to Poland for an on-site work at our client there. I am not used to such type of work, but I think it went very well. Besides answering questions and troubleshooting issues, I also coded a few simple tools that help them solved some problems. The work was diverse and interesting, and it kept me busy all day. It was pretty exhausting too, so I am grateful that my lovely fiancé (now my wife) came for the second week to make my stay in Poland much more pleasant. It really helped me get my work-leasure balance back.

Interviewing candidates for a developer position – the last month I participated in several interviews (I’ve used to be only from the other side of the table). I was responsible for evaluating their technical abilities. Although the CVs gave hints about what the candidate knows and is capable of, asking proper questions sometimes revealed unexpected voids in the knowledge of people. Btw, in my first interview I was totally unprepared and didn’t know what to ask, but after some research on the topic I became more adequate to the task, though I guess I could be more creative. In addition to the interview questions, I also prepared a simple coding homework assignment that we were giving to the candidates. I am happy we used this approach since it showed pretty well how people approach code and what their skills are. It was also interesting to notice how differently people could try to code their way through such a simple problem.

Looking towards 2011 – I already mentioned what are my preferences about my career development for the new year. I hope that it will be a great year for everyone I work with. I wish my colleagues all the best, to keep it cool and to their best to maintain a friendly and supportive work environment.

Release notes – less or more structured approaches

2010-12-27T09:24:00.001+02:00

Continuing my post from last week, I’ll briefly explain how we maintained a change log in my company for about an year (this was back in 2009) and what were the the things we liked and disliked about it.

We used a shared OneNote notebook that had a page per each internal build. After a developer had checked-in a bugfix or some new functionality, he had to describe the change in a free text format, Pasting screenshots was encouraged too, when applicable. The OneNote looked like that:

We chose OneNote because of its several conveniences:

Easy to setup and use.
Allows concurrent editing.
Easily searchable.
Allows WYSIWYG rich text formatting (including pasting screenshots)

Actually we didn’t use many OneNote features. It was just a visually appealing and easy-to-setup wiki. I think it was pretty useful for devs and QAs in terms of shedding more light in the product development. People could quickly got a good idea how features were evolving and be kept up-to-date with the changes in a non-obtrusive way.

But there were several things that were not that great about this process:

Some developers complained that it was getting too difficult to commit changes: first they had to write checkin comments, then they had to write a resolution in the issue tracking system, and finally they had to update the change log. Though the comment text could slightly differ, sometimes it seemed like a duplication.
It was not that easy assemble all the changes for the official release notes from the changelog. One of the reasons was that changes were organzied by date, while it made more sense to have them finally grouped by component and sorted by importance. Also the writing style of developers differs, so it was necessary to rephrase many of the changes.
Since the log has loose structure, it was not possible to query the changes, e.g. “find me the fixes by developer X made in the past 2 weeks”.

So I was thinking why not capture all release notes information in the issue tracking system itself. The advantages of such approach are obvious, but the system has to meet several requirements for this to work well:

Support custom fields (for a text field “DescriptionForReleaseNotes” and probably another one “ImportanceForReleaseNotes”)
Support specifying in which release was the change made.
Support specifying the component that changed.
Support generating a custom report that for any selected release(s) outputs the non-empty changes, grouped by component and sorted by importance.

I guess that most popuplar issue tracking systems would support the first three features. I have my doubts only for the report, but some systems might offer powerful enough reporting out of the box. And even if they don’t, exporting the result to Excel and doing some data manipulation there, is an option, too.

Another challenge is that this approach assumes that each item in the release notes should describe only one issue in the system, which is not always the case. You might want to group several small changes in one area in a single item. Well, you can just put a value in DescriptionForReleaseNotes for only one of them, but it will be difficult to manage this, unless there is a support for linking the other related issues to the one that contains the description. So linking issues is probably another requirement for this approach to work well.

So is it worth commiting to such a highly structured approach of storing release notes? I am not sure. If your issue tracking system can handle such process well, it might be relatively painless to adopt it. But if you have to use another tool just for managing release notes, it might be an overkill. What do you think?

Release notes – whats and hows

2010-12-19T23:55:00.001+02:00

So you are asked to prepare a detailed list of changes in the last N months that would be the basis for creating the release notes for the brand new shiny version of your product. Unfortunately you have not been maintaining a change log throughout the product development. Naturally you can’t come up with a detailed list from the top of the head (even for the stuff you developed yourself). In order to do a decent job, several people have to invest hours (or days) to dig out stuff from various sources: the SCM system, the help desk, design documents, e-mails. Under time pressure they have to formulate the changes in a way that they make sense for the target audience. And if the deadline is tight, you might sacrifice the quality of the release notes. That’s stressful and inefficient. But before digging deeper on how to take preventive measures, let’s first take a look at what’s the purpose of release notes/change log and how to prepare them.

What is the target audience of a change log/release notes?

I initially planned to use the terms “change log”, “release notes” and “revision history” as synonims. But I have a subtle feeling that a change log is for internal audiences, while release notes/revision history are targetted to the end users. A change log also seems to have a connotation of an on-going effort, while release notes are often created just before the release as a one-time effort.

It’s clear that not only the end users (current and prospecitve clients) are interested in what’s fixed/ehnahnced/added. A lot of people involved in the product development need such information and they surely need it on a much more regular basis. The list of the internal stakeholders includes QAs, technical writers, developers, customer support, consultants, trainers, management. Probably everyone is interested in slightly different subset (or aspect) of the changes, but to keep things simple let’s examine for now only the differences b/n internal and external change logs.

Targeting external vs internal audience

The purpose of an external release notes (i.e. publicly visible & easily discoverable) is not only to inform, but most importantly (from the business perspective) is to:

Advertise what goodness the new release brings – how does it empower the user (or at least alleviate some of his pain)
Increase the confidence in the product and the company behind it - by demonstrating that serious efforts are put in its development and that there is a significant progress on many fronts.

The purpose of the internal change log is to make sure that everyone knows what is going on in the development and to take this in consideration while doing their job. It’s necessary to have additional information about the circumstances of the change (e.g. who was the developer behind the change, so he can be contacted later). The purpose here is just to inform (not to persuade), but still the description of each change should be done concisely from the perspective of the product evolution.

How release notes should be written?

I was looking for an answer of this question myself before deciding to write this post. I found several good answers at stackoverflow and in a blog post. But let’s first take a look at some sample release notes to have some background.

I spent a few hours looking at the release notes of a dozen of products (some of which I’ve used, some I’ve just been interested in). Here are a few links of various product types:

.NET control suites: Telerik , Infragistics, DevExpress, ComponentOne.

VS.NET addins: ReSharper, TestDriven.Net, Typemock, Entrian Source Search

SCM systems: Mercurial, PlasticSCM, Subversion, Vault

If you looked at the release notes, you’ve probably noticed that they differ both in terms of content and presentation:

Content

Highlights : more often than not, release notes start with an overview of the most important changes

Leaving out the bugs: some release notes don’t include list of fixes, but only improvements (or at least the list of fixes can be found in other not as easily accessible location). Since there is no bug-free software that I know of, I guess the this information filtering is geared mostly towards attracting new customers.

Level of detail: some vendors prefer to describe changes in the most laconic way possible, some are more descriptive

Automatically generated: some changelogs appear to be generated directly from the issue tracking system (or even from the source control system), but most of them look hand-crafted (especially in cases when rich output formats are used, e.g. pictures :) )

Presentation

Output Format: plain text vs richer format (HTML, PDF, etc.). Rich formats are more expressive & more visually appealing, but for some types of products a plain text change log might be just good enough.

Organization of the list of changes: usually the changes are grouped/sorted by component and/or by change type. The change types can be as basic as ADDED, IMPROVED, FIXED (see Telerik), though some vendors like JetBrains use more detailed types: Bug, Cosmetics, Exception, New Feature, Performance Problem, Usability Problem, Meta Issue, Task (as ReSharper).

Continued…

This post got rather lengthy, so I am continuing this topis in my next post with a brief analysis of what kinds of tools you could use for manageing change logs. I’ll share some of my experience and will discuss the pros/cons of different approaches.

Devreach 2010

2010-10-20T00:51:00.001+03:00

The 5th edition of Devreach was again excellent - so many world-class speakers, who are passionate about development.

I visited the following sessions:

Anti-Corruption Layers by Donlad Belcham, Level200

What's New in WCF 4 by Miguel Castro, Level 200

Kanban and Scrumban by Joel Semeniuk, Level 200

Leveraging Client Capabilities with jQuery in Visual Studio by Robert Boedigheimer, Level 300

Dynamic State Storage Using the ASP.NET Provider Model by Miguel Castro, Level 300

Customizing TFS to Your Needs by Joel Semeniuk, Level 300

Deep dive into Load Testing features in Visual Studio 2010 by Martin Kulov, Level 300

Worst Practices and Anti-Patterns of Software by Steven Smith, Level 200

Automated Testing in the Agile Environment by Christopher Eyhorn, Level 300

I have to say that none disappointed me – most of them were both informative and entertaining. Altough there were 5 parallel streams of lectures for each time slot (Presentation Layer, Data Layer, Business Layer, Best Practices, Architecture) the titless that grabbed my interest were usually just one or two.

I am not sure how much value the information from this conference would bring to my work, but at least it is refreshing to hear (or get remineded) about various practices, approaches, technologies and fantasize how they might help you in you everyday job.

Summary of the year 2008

2008-12-25T15:47:00.002+02:00

Another quite year of blogging, though the last quarter this blog was somewhat resurrected.

It has been 2.5 years since I started working on Validata product. The last year was moderately interesting one,. I worked on various staff, the most notable of which are an HTTP load testing tool (pretty challenging task) and a language parser using ANTLR (just for a week). I also continued to work on our web application and a couple of desktop applications. I feel good that some my ideas finally were implemented and went in production. Also I think my efforts to improve our development process start to pay off...

Unfortunately my pet project with ActiveRecord, Monorail, MySql, JQuery that I got started was put on hold in february, but still it was a good learning experience. After getting to know Monorail, now I quickly got was ASP.NET MVC all about.

Next year, I plan to become an MCTS (I think my company finds more value in those certifications, than I do), so I am starting with 70-536. As a matter of fact, this morning I finally took a practice test from the training kit. I expected to top it without reading a word from the training book, but wishful thinking did not suffice :) I realized that there are areas of the .NET Framework that I don't know enough about i.e. .NET Security, WMI, Interoperability. I wonder if I concentrate only on those areas, will this be enough to pass the exam. Having solid 4 years experience in the .NET world should be a good starting point, so reading a few chapters for a couple of days might be exactly what I need.

Helper for ANTLR Grammar

2008-11-05T11:36:00.001+02:00

So I mentioned I am working on a ANTLR grammar (though not for long). And the experience with it was not always smooth.

The problem

We are trying to define a grammar for an existing language which is pretty complex (several hundreds of statements). Every new parser rule had the potential to break the grammar. After inputting several rules, we had difficulty identifying the problematic one. It required a lot of discipline to compile the grammar after each change.
Two developers are preparing the grammar together. Once or twice a day, we are merging the .g file. The merging proved to be quite error-prone.
The ANTLRWorks IDE is not always stable. In some scenarios it freezes and has to be restarted.
The errors and warnings were displayed together, so we had no way of filtering only errors (and we had many warnings).
The C# code generation is buggy in some scenarios - we got an error of a duplicate identifier.
After each compilations we had to overwrite the lexer and parser CS file in our C# project.

The solution

So I wrote an desktop application that monitors the ANTLR grammar file and on each change, it compiles it and does some post-processing to fix the C# code using a simple regex.

Other features

· Specify settings in .config file (grammar file, working folder, antllr install dir)

· View compilation output - complete output, and only errors

· View history of compilation attempts and results

· View notifications as balloon tips (displayed only on significant changes – broken grammar and fixed grammar)

· Automatically save the last successful build in a subfolder of the working folder

Was it worth it?

Yes, automating error-prone operations is always a good idea. We had problems with merging a few times and this continuous compilation enabled us to quickly find the problematic rules. The tool took me initially 3 hours to develop and additional 50% to maintain and bug fix.

How could we extend it?

Generating the C# files from the grammar is not enough. Its output should be included in the project. Then compile successfully. Then pass some unit tests. We have not reached this stage yet.

Points of interest

There is a good discussion here about how to change the .g file, save, hit F5 in Visual Studio and have it use the most recent version of the generated files. Apparently you need a custom tool to do so. A custom tool as a managed assembly that contains a class that implements the IvsSingleFileGenerator interface. Here is a link to an article how to create such a custom tool.

P.S. If you are interested in the code, let me know. I would have uploaded it on CodePlex, but currently it has a dependency to a third-party grid, so I should better use a normal grid, instead.

My Meta Parser

2008-10-29T16:41:00.001+02:00

This is fun... I am working now on a task related to ANTLR and its grammar files. Since the grammar file got big and a bit messy, I wrote a small utility to parse the grammar file (.g file) and to sort the parser rules by name. So there it is: a parser of the parser... my meta parser

NOTE: Well, it was not a full-blown parser, but having the parser rules more strictly structured, made it easy enough to implement.

Ways to Compare .NET Assemblies

2008-10-27T09:37:00.001+02:00

Sometimes comparing source code is not a viable option, and one has to resort to comparing assemblies (hopefully not obfuscated) to find out what is new, what has changed and what is removed. This kind of activity can be useful in many ways:

Determine what amount of work was done between two releases
Estimate the impact of the changes (e.g. what is needed to be retested).
Spend some work time doing playing with such amusing stuff :)

But how could you do it:

Commercial Tools

NDepend - I have only watched their video and it is impressive. Unfortunately the trial version does not support build comparison, so you should buy the product to try it for yourself. It is a pretty feature rich product that you can use for a variety of reasons.

Bitdiffer - This sole purpose of this tool is comparing assemblies. It lacks some of the NDepend visualizations goodness, but is nevertheless an excellent tool. You might use its GUI application as well as its command line version to automate your work.

Poor Man's Tools

Reflector Diff AddIn - We all love Reflector and this is one of its useful addins. You can either view the differences or you can have a XML report.

Framework Design Studio - There is a short review here. Unfortunately the tool does not work with all assemblies and I can't report good results with it.

VS.NET Macro To Display All File References in a VS.NET Solution

2008-10-23T14:31:00.001+03:00

The problem: You have a large solution (mine is with 154 projects) and you want to quick find if you use file references and to what assemblies are they).

The solution: see the files below. Add the following module and class and execute ShowAllFileReferencesGroupedByProject()

Module:

Imports System

Imports EnvDTE

Imports EnvDTE80

Imports System.Collections.Generic

Imports System.Diagnostics

Imports System.Text

Imports System.Windows.Forms

Public Module VsProjectsManagement

Public Sub ShowAllFileReferencesGroupedByProject()

Dim sb As New StringBuilder()

Dim finder As New FileReferencesFinder()

Dim fileReferences As Dictionary(Of VSLangProj.VSProject, List(Of String)) = finder.GetAllFileReferencesInSolution(True)

Dim sortedProject As New List(Of VSLangProj.VSProject)(fileReferences.Keys)

sortedProject.Sort(AddressOf FileReferencesFinder.CompareProjectsByName)

For Each proj As VSLangProj.VSProject In fileReferences.Keys

sb.Append(proj.Project.Name).Append(" : ").AppendLine()

For Each reference As String In fileReferences.Item(proj)

sb.AppendLine(reference)

sb.AppendLine()

Debug.Write(sb.ToString)

MessageBox.Show(sb.ToString, "File references")

End Sub

Class FileReferencesFinder:

Imports System

Imports EnvDTE

Imports EnvDTE80

Imports System.Collections.Generic

Imports System.Diagnostics

Imports System.Text

Imports System.Windows.Forms

Public Class FileReferencesFinder

Private Function GetAllSolutionVsProjects()

Dim vsProjects As New List(Of VSLangProj.VSProject)

For Each proj As Project In DTE.Solution.Projects

If TypeOf proj.Object Is VSLangProj.VSProject Then

vsProjects.Add(proj.Object)

End If

Return vsProjects

End Function

Public Shared Function CompareProjectsByName(ByVal prj1 As VSLangProj.VSProject, ByVal prj2 As VSLangProj.VSProject) As Integer

Dim name1 As String = prj1.Project.Name

Dim name2 As String = prj2.Project.Name

Return String.Compare(name1, name2)

End Function

Public Function GetAllFileReferencesInSolution(ByVal ignoreNetFrameworkAssemgblies As Boolean)

Dim fileReferences As New Dictionary(Of VSLangProj.VSProject, List(Of String))

For Each vsProj As VSLangProj.VSProject In GetAllSolutionVsProjects()

Dim references As List(Of String) = GetProjectFileReferences(vsProj, ignoreNetFrameworkAssemgblies)

If references.Count > 0 Then

fileReferences.Add(vsProj, references)

End If

Return fileReferences

End Function

Private Function GetProjectFileReferences(ByVal vsProj As VSLangProj.VSProject, ByVal ignoreNetFrameworkAssemgblies As Boolean)

Dim fileReferences As New List(Of String)

For Each objReference As VSLangProj.Reference In vsProj.References

If objReference.Type = VSLangProj.prjReferenceType.prjReferenceTypeAssembly Then

If objReference.SourceProject Is Nothing Then

If ignoreNetFrameworkAssemgblies Then

If objReference.Path.StartsWith("C:\Windows\Microsoft.NET\Framework\") Then

Continue For

End If

If objReference.Path.StartsWith("C:\Program Files\Reference Assemblies\Microsoft\Framework\") Then

Continue For

End If

fileReferences.Add(objReference.Path)

End If

fileReferences.Sort()

Return fileReferences

End Function

End Class

DevReach 2008

2008-10-20T16:53:00.001+03:00

A week after the event, I am writing a short review of some of the presentations on DevReach conference

Key Note - by Stephen Forte - very funny keynote. Also a great historical overview of Microsoft strategy for the data access. Steohen showed good examples that Microsoft is a reactive (not a proactive) company.
To AJAX or Not to AJAX by Lino Tadros - Ajax sometimes can be slower, really. Good talk and demos.
Introduction to Test-Driven Development by Stephen Forte - An introduction in TDD, One gem from it was Stephen telling us how to sell TDD to managers - just create regression bugs. Unfortunately Stephen did not tell that TDD is more about about design than testing but another presenter did that in a later session.
Pragmatic ASP.NET Tips, Tricks, and Tools, Part 1 and Pragmatic ASP.NET Tips, Tricks, and Tools, Part 2 by Steven Smith - some useful tips here. This was actually the most practical talk I attended.
Designing for Testability by Hadi Hariri - very good lecture, though it did not turn as interactive as the presenter expected. I am becoming increasingly interested in inversion of control.
SQL Reporting Services 2005 and What's New in 2008 by Remi Caron - I had used RS 2005, but this talk was not for me. SQLRS is not the best tool at the market, but I guess it is popular in Microsoft shops.
Effective Risk Management With and Without Team Foundation Server 2008 by Tadeusz Golonka - the presenter English was really unique. There were a few good ideas how to measure and manage risk.

NOTE: I am pleased that for the first time I saw presenters who used ReSharper in their demos Steven Smith and Hadi Hariri. Both of them used a dark scheme for VS.NET. Unfortunately people complained and they had to switch to the default colors.

XmlWriter design flaws

2008-03-12T14:09:00.002+02:00

I was very surprised to see an XmlException (hexadecimal value... is invalid character) when using a XmlReader on a XML file that was generated using a XmlTextWriter. It turned out that the method WriteString(String) does not check for some special characters and an invalid XML document might get generated. See details here.

The recommended workaround was subclassing XmlTextWriter and overriding WriteString() to handle this characters (remove or substitute the invalid characters). XmlTextWriter constructors accept parameters like Stream, TextWriter, but there is also a static factory method XmlWriter.Create(), which has overloads that accept an optional XmlWriterSettings parameter. The weird thing is that if no XmlWriterSettings is specified, then the Settings property of the XmlWriter is null and can not be instantiated, since it is readonly. This means that there is no way to create a subclass (e.g. SafeXmlTextWriter), with initialized Settings property. So, if the default settings are not applicable to your situation... well, tough luck, you can not apply the easy fix using the override:

public override void WriteString(String value)
{
value = FixInvalidCharacters(value);
base.WriteString(value);
}

Summary of the year 2007

2008-01-01T19:00:00.000+02:00

2007 seems a rather quiet year in my career (at least blogging-wise). But it was quiet in a good way :)

It has been 1.5 years since I started working on Validata product and it continues to be mentally stimulating and fun. The diverse technologies in the project and the interesting problems keep me excited about my job. My company has joined a few projects in the Balkans, so the week before Christmas, I had my first business trip, ever. I went for Romania and next week I am going again.

I also have started a pet project that requires learning new stuff like ActiveRecord, Monorail, MySql, JQuery and other good stuff. I really hope to kick it off to a good start, while I am still on vacation. The more challenging thing is to make it a habit to have progress each day, no matter how little it is. I was somewhat unpleasantly surprised when I realized that it has been almost 3 months of inactivity from my last refining of the project idea. But now the project has stable foundations, there are no pending major technology decisions, so the work might just flow...

I have been keeping up with the new .NET stuff mostly from reading my daily doze of weblogs. I also attended a great seminar in Sofia in October, so the saw is still being sharpened :)

I have continued to refine my toolbox and programming techniques. I find that it's worth the temporary discomfort in learning how to use a new tool or technique.

I have a good feeling about the new year. And I will try to make this a self-fulfilling prophecy :)

Have a great new year!

DevReach 2007, Sofia, Bulgaria (Day 2)

2007-10-02T23:13:00.000+03:00

Just a few quick notes about the session I visited in the Day 2 of DevReach.

Why Partial Rendering Is Not AJAX
by Dino Esposito, Level 300

Another excellent talk by Dino. I finally cleared some misconceptions in my head about AJAX, partial rendering, update panels and all this stuff. This was a practical talk that will help me a lot when I do AJAX again (the first attempt was a bit unsuccessful, but you know AJAX is not for the faint-hearted).

Silverlight, Flash on Steroids
by Lino Tadros, Level 200

An excellent talk, by an honest and humorous speaker. Lino's SL demo app was simple and well chosen. But Silverlight is still nor ready for prime time, since the tools are lacking and there are some basic controls missing etc.. (well, when 1.1 is ready, I might take a look at it again).

Being Smart About Database Design
by Vladi Tchalkov, Level 300

Very interesting talk about database design considerations: normalization, domain tables, keys, temporal tables, optimizations. One of the concepts I found very useful was one idea of how to implement temporal tables with a single table for the whole DB. One repeating thread in the talk was "know the rules so that you know how to break them properly".

RSS, Podcasting, and Syndication
by Carl Franklin, Level 200

A nice talk by the .NET Rocks host Carl Franklin. I learned about the Argotic .NET library. And Carl was very proud that his .NET rocks feed was valid, while the NY times was not (see FeedValidator) :)

LINQ - Deep Dive
by Branimir Giurov, Level 400

Branimir covered in detail all types of LINQ (for objects, datasets, SQL, Entities, XML). He showed the cool debugging support. Good stuff, looking forward to using LINQ.

A Busy Developer's Guide to Building Windows PowerShell Cmdlets
by Hristo Deshev, Level 200

My friend Hristo gave a very interesting talk about PowerShell Cmdlets (he is also writing a book on PowerShell, so he knows his stuff). Those Cmdlets are very fast to build and really powerful. I would like to play with them in case I have to do BAT commands or something more complex.

DevReach 2007, Sofia, Bulgaria (Day 1)

2007-10-01T18:57:00.000+03:00

I missed the first DevReach in 2006, but this year I made it to the conference. All of the speakers on Day 1 were really good and they captivated me till the end of each of the sessions. Here is a quick recap of the talks, that I visited.

Side note: I don't know if it was just for the presentation, but none of the speakers that showed code in VS.NET had ReSharper installed. Just weird! :)

Developers are from Mars, Managers are from Venus
by Chad Hower, Level 200

I decided to start with a light and entertaining talk. I definitely got what I came for. Great slides, very humorous presentation... At one point in the presentation Chad asked his audience how many of us work for in a team of more than 10 people and only one guy (out of the fifty in the room) raised his hand. So, yes, there are very few projects that need heavyweight methodologies meant for building the software analog of aircrafts. Chad said that giving names such as lightweight vs heavyweight is not very fair, so he used the terms project-based and product-based methodologies (those were new ones for me).

Creating a billion dollar ERP system - case study of Velocity
by John Waters, Level 300

I didn't read the abstract of this talk and was a bit surprised (but in a pleasant way) that it was a very practical talk using a real code base. I finally understood what was the difference between ajax postbacks and ajax call. It was also useful to see how ajax works in practice, where does it make sense to use it and what is the cost of doing so.

Challenging ASP.NET/AJAX for Braveheart Developers
by Dino Esposito, Level 300

Again I didn't read the abstract carefully and was surprised that the talk was about: HTTP handlers and modules. But this was a very interesting topic that I knew very little about (only ELMAH sounds familiar). Dino gave his talk very passionately and went without hesitation 10 minutes in the coffee break. One cool thing he showed was a HttpModule, that I think it was called ASPExlorer). It got activated by appending a parameter in the querystring "source=true" and it made the HTTP response return useful information about the requested page: its assembly file path, its dependencies, its source code, etc... Pretty cool way for troubleshooting in production environment.

Scaling Habits of ASP.NET Applications
by Richard Campbell, Level 300

Richard (whom I have listened to a lot in .NET Rocks) was probably the most eloquent and artistic speaker. He definitely knew his stuff, too. His session was definitely useful since I was unaware about a lot of stuff concerning ASP.NET scalability and performance. One quote worth remembering: "Computers are amplifiers - they just amplify the developer's intelligence or stupidity!"

I am sure that the session in Day 2 will bring more good sessions (just like the ones today)...

Blindspot: 'hh' vs 'HH'

2007-07-06T17:18:00.000+03:00

This is maddening! After working with .NET for more than 3 years, I just realized that I should be using HH (and not hh) to show 0-24 hours in a formatted DateTime. It is weird how I held this misconception for such a long time. If my workdays were from 00:00 to 12:00, then this could be justified, but that's definitely not the case...

Do you like surprises?

2007-06-29T14:37:00.000+03:00

Tony Robbins asked his audience in a TED talk if they like surprises. He received a resounding "YEAH", but he continued with the comment: "BULL****, people like only the surprises they expect". Let me tell you about two developer's surprises from yesterday (I guess, I didn't like those much):

Javascript Surprise: In a ASP.NET project I had to implement a client-side filtering of table rows. I registered a javascript array with values to be compared. Since it was very slow I decided to sort the array server-side and use binary search client-side. The script ran much faster, but in some cases it didn't work as expected. The surprise factor turned out to be that .NET and javascript did string comparison in different way, so the array was not sorted correctly ("A" < "b" in .NET but"A" > "b" in Javascript).

Oracle Surprise: I use tnsnames.ora to connect to Oracle and tnsping.exe tells me to what service I am currently connected to. It turned out that this is not always reliable if you have multiple tnsnames.ora. So, I have been working for quite a long time on a database that was not the one I expected. More info on the topic here and here.

The developer's job is not short of surprises, so better approach them with eagerness or join a club like this one.

Becoming VS.NET Keyboard Jedi

2007-06-22T18:18:00.001+03:00

After improving my general typing speed, getting more comfortable with the keybaord and obtaining a MS Natural Ergo 4000 keyboard, the next step to increase my productivity at work is to do more in VS.NET without using the mouse device.

I will need some discipline to leave the mouse navigation habit behind, but I think it will be worth it. The preconditions for a successful migration are:

Roy's Keyboard Jedi
Learning the shortcuts: VS.NET and Resharper
One week commitment - if I don't feel comfortable in a week with the keys, I don't plan to be extra stubborn

I will report on my progress next Friday :)

UPDATE: Next Friday's report: It turned out that I found it impractical to abandon the mouse completely. In a lot of cases reaching to the mouse was easier: navigating through various VS.NET windows, running rarely-used commands, etc. On the bright side, I succeeded to replace some mouse movements with the corresponding key strokes both in VS.NET and in other applications. Now I find it natural to navigate through text and select text with the keyboard.

Cool: Design Your T-Shirt Online

2007-04-01T01:08:00.000+03:00

I just stumbled upon a great site http://www.click-shirt.com/ where you can design your own T-Shirt online with an amazing Flash interface - it puts you in a creative mood, right away.

I could not help it and started with a standard template. In 10 minutes came up with this crazy T-Shirt design...

Don't ask what all of this means! There is a deep and profound explanation for each of the symbols, letters, graphics you see, but I am yet to figure it out...

Hmm, I better get some sleep and in the morning I may censor this post, since it is way off topic. But on the other hand it supports may intention to start adding more visual elements to my posts, so I'll better leave it here as a reminder.

Controlling the number of active users of an ASP.NET application

2007-03-24T12:02:00.000+02:00

Last week out team had to implement a requirement that limits the number of concurrent active users of an ASP.NET application. In order to deal with concurrent users, there should be a continuous interaction between the user and the application, which does not match very well the essence of web applications: request-response. Since our app is meant to be an intranet application (used mostly like a desktop app), such a licensing scheme makes some sense. And the concept of an ASP.NET session denotes a continuous communication, so it provided a good way of determining who is an active user and who is not.

I was surprised that I could not find a way to directly control the active ASP.NET sessions - e.g. kill a session (by its SessionID), get the session data, etc. As a workaround, we used a two-step process: keep the IDs of the active sessions in a "session manager" and when some event occurs (e.g. the max number of concurrent users is reached) mark a session "to be killed". That's how the next request from a "to be killed" session, forces the session to be abandoned.

This schema worked nicely, until we noticed that closing the browser and reopening it again caused a new session to be registered in our "session manager". The previous one remained alive since the ASP.NET application did not know that the user had closed his browser (ASP.NET session ID cookie is stored only in browser memory, so it gets lost). So we came up with another workaround and used a persistent cookie to identify that the user has finished a session and started a new one.

The thing that I don't quite like, is that we started with a simple problem and developed a pretty complex solution. I wonder if there was a more elegant way to deal with the concurrent users issue.

VS.NET 2005 Macro For Removing Unnecessary Projects From A Solution

2007-03-12T19:05:00.000+02:00

I usually work with a pretty large VS.NET solution. Currently It contains 60 projects and I don't need them all of the time. To ease the solution loading and help VS.NET add-ins like ReSharper load and function faster, it is a good idea to split this solution into several smaller ones. Since the projects interdependencies are not that simple, I decided to automate the process of creating the smaller solutions.

The macro below finds all projects referenced of the selected ones and removes the other projects from the solution. Then you one can do "Save as" and use the shrinked solution. Use ShowAllReferencedProjects() for displaying the projects that will remain after the operation and RemoveAllProjectsUnusedByActiveProjects() for the actual removal (you will be asked if you are sure you want to do that).

Note: Excuse my VB, I have not exercised my VB skills, since doing some VB6 coding more than two years ago. The part that was most fun and challenging was not VB, but exploring the VS.NET object model - surprisingly the resources on this topic were a little scarce.

Disclaimer: Use the code at your own risk! (well, it can't really do much harm, since it does not save the solution automatically).

UPDATE: Well, actually RemoveAllProjectsUnusedByActiveProjects() can affect some of the project files, since the order of removal turned out to be important (removing a referenced projects, shortens the reference lists of other project). This issue is fixable, but currently I don't have the time to fix it :) Moreover the operation is very slow so it might be easier to add projects to a blank solution instead of removing them from existing solution. Actually, the best way to handle this task is on a file level, where you need a parser for solution and project files. Parsing those files will not be that trivial and I had not been able to find such parsers online. Looks like a good idea for a pet project :)

Imports System
Imports EnvDTE
Imports EnvDTE80
Imports System.Collections.Generic
Imports System.Diagnostics
Imports System.Windows.Forms

Public Module VsProjectsManagement
Public Sub RemoveAllProjectsUnusedByActiveProjects()

Dim unusedProjects As List(Of VSLangProj.VSProject) = FindAllProjectsUnusedByActiveProjects()
If unusedProjects.Count = 0 Then
MessageBox.Show("There are no unused projects for the current project selection")
Exit Sub
End If

Dim s As String
s = "Do you want to remove the following " & unusedProjects.Count & " projects from the solution: " _
& GetProjectNames(unusedProjects) & "?"

If Not DialogResult.Yes = MessageBox.Show(s, "Unused projects removal", MessageBoxButtons.YesNo, MessageBoxIcon.Question) Then
Exit Sub
End If

RemoveProjectsFromSolution(unusedProjects)

End Sub

Public Sub ShowAllReferencedProjects()
Dim usedProjects As List(Of VSLangProj.VSProject)
usedProjects = FindAllProjectsReferencedByActiveProjects()

Dim s As String
s = "The selected project(s) reference total of " & CStr(usedProjects.Count) _
& " projects in the solution: " & GetProjectNames(usedProjects)

MessageBox.Show(s, "Referenced projects")
End Sub

Sub RemoveProjectsFromSolution(ByVal projects As List(Of VSLangProj.VSProject))
For Each vsProject As VSLangProj.VSProject In projects
DTE.Solution.Remove(vsProject.Project)
Next
End Sub

Function GetProjectNames(ByVal projects As List(Of VSLangProj.VSProject)) As String
Dim projectNames As List(Of String) = New List(Of String)(projects.Count)

For Each vsProject As VSLangProj.VSProject In projects
projectNames.Add("'" & vsProject.Project.Name & "'")
Next

projectNames.Sort()

Return String.Join(", ", projectNames.ToArray())

End Function

Function FindAllProjectsUnusedByActiveProjects() As List(Of VSLangProj.VSProject)
Dim allVsProjects As List(Of VSLangProj.VSProject)
Dim vsProject As VSLangProj.VSProject

allVsProjects = FindAllVsProjectsInSolution()
If (allVsProjects.Count = 0) Then
Debug.WriteLine("There are no Projects In Solution")
Exit Function
End If

Dim allActiveAndReferencedProject As List(Of VSLangProj.VSProject)
allActiveAndReferencedProject = FindAllProjectsReferencedByActiveProjects()

Return DifferenceProjects(allVsProjects, allActiveAndReferencedProject)
End Function

Function DifferenceProjects(ByVal mainSet As List(Of VSLangProj.VSProject), ByVal setToRemove As List(Of VSLangProj.VSProject)) As List(Of VSLangProj.VSProject)

Dim resultSet As New List(Of VSLangProj.VSProject)

For Each vsProject As VSLangProj.VSProject In mainSet
If Not setToRemove.Contains(vsProject) Then
resultSet.Add(vsProject)
End If
Next

Return resultSet
End Function

Function FindAllProjectsReferencedByActiveProjects() As List(Of VSLangProj.VSProject)

Dim activeVSProjects As List(Of VSLangProj.VSProject)
Dim allActiveAndReferencedProject As New List(Of VSLangProj.VSProject)
Dim vsProject As VSLangProj.VSProject

activeVSProjects = FindAllActiveVsProjects()
If (activeVSProjects.Count = 0) Then
Debug.WriteLine("Please select one or more projects in the solution")
Exit Function
End If

' fill first the initial selected projects
For Each vsProject In activeVSProjects
allActiveAndReferencedProject.Add(vsProject)
Next

' find all referenced projects recursively
For Each vsProject In activeVSProjects
FindAndFillReferencedProjects(vsProject, allActiveAndReferencedProject)
Next

Return allActiveAndReferencedProject
End Function

Function FindAllVsProjectsInSolution() As List(Of VSLangProj.VSProject)

Dim usedVSProjects As New List(Of VSLangProj.VSProject)

For Each proj As Project In DTE.Solution.Projects
If TypeOf proj.Object Is VSLangProj.VSProject Then
usedVSProjects.Add(proj.Object)
End If
Next

Return usedVSProjects
End Function

Function FindAllActiveVsProjects() As List(Of VSLangProj.VSProject)

Dim usedVSProjects As New List(Of VSLangProj.VSProject)

For Each proj As Project In DTE.ActiveSolutionProjects()
If TypeOf proj.Object Is VSLangProj.VSProject Then
usedVSProjects.Add(proj.Object)
End If
Next

Return usedVSProjects
End Function

Sub FindAndFillReferencedProjects(ByVal objVSProject As VSLangProj.VSProject, ByVal usedVSProjects As List(Of VSLangProj.VSProject))

Dim referencedVSProject As VSLangProj.VSProject
Dim proj As Project

For Each objReference As VSLangProj.Reference In objVSProject.References
If objReference.Type = VSLangProj.prjReferenceType.prjReferenceTypeAssembly Then
proj = objReference.SourceProject
If Not proj Is Nothing Then
If TypeOf proj.Object Is VSLangProj.VSProject Then
referencedVSProject = proj.Object
If Not referencedVSProject Is Nothing Then
If Not usedVSProjects.Contains(referencedVSProject) Then
' Add current and recursively add the others
usedVSProjects.Add(referencedVSProject)
FindAndFillReferencedProjects(referencedVSProject, usedVSProjects)
End If
End If
End If
End If
End If
Next

End Sub

End Module

Counting Tools

2007-01-09T17:07:00.000+02:00

At work, I employ a myriad of tools to get my job done, and I am always trying to add new goodies to my toolbox. Naturally some of the programs I try just don't prove useful enough to stay around for long. To keep my system tidy (mission impossible), occasionally I run MyUninstaller to remind myself what applications I have installed and eventually remove the ones that I will never use. Recently I noticed that there are 300 installed items (but excluding the security updates there are about 200 applications). Since those are only the tools that had been installed using MSI, I guess, that the actual app count is actually greater than 300 (most likely about 400).

But if this post can be useful for anybody, I better include links to some of my recent additions to my toolbox:

Today I liked a bunch of tiny useful apps from donationcoder (the list on the site is huge, but only a few apps have a chance to prove useful):

CAPshift - Ever hit caps lock by accident and not found out until half a page later? CAPshift extends the Caps Lock key by slowing it down, and shows a menu to change the selected text to lowercase, UPPERCASE, TitleCase, iNVERTEDcASE, RaNDoMCaSE or to Replace user defined characters.
StartClock - Shows the current time in the start button.
OpeningHours - Runs a program when inside a certain time interval, and closes it when outside.
LabelControl - Overlays buttons and other controls with a Number for direct access via Ctrl-Number.

Other great tools that deserve mentioning are:

StExBar - The StExBar provides many useful commands for your everyday use of Windows explorer. The best feature is having Ctl+Shift+C for copying path of the selected file.
WinDirStat - WinDirStat is a disk usage statistics viewer and cleanup tool for Microsoft Windows. It is just the best free tool I have tried and it helped me make some space on my disk.

And let's throw in some good recent additions to my ever-growing list of killer Firefox extensions:

ErrorZilla 0.2 - Implements useful error pages.
Link Alert 0.6.2 - Changes the cursor to indicate the target of a link.
Linkification 1.3.1 - Converts text links into genuine, clickable links.
Disable Targets For Downloads 1.0.1 - Prevents download links opening a blank window.

Summary of the year 2006

2007-01-01T15:39:00.000+02:00

It is already a tradition to do an opening post that sums up what I have been up to in my professional development in the past year.

It was a pretty interesting year! Finishing off my first project for my (not so new) company, completing another small one, and joining a long-term challenging project (the biggest one in my career). And some coding 4 fun :)

The biggest change for me this year was entering the world of web programming. ASP.NET made the transition from desktop to web programming pretty smooth, but still there is so much too learn. Using .NET 2.0 and VS.NET 2005 for nearly a full year was valuable experience as well and a pretty enjoyable one, as well.

My skill improvements program this year included learning touch typing. I think that the hours invested in it already paid off pretty well.

A couple of computer books that I read and found interesting were Working Effectively With Legacy Code and Balancing Agility And Discipline.

I also kept investing a lot of time to improve my tools at work (see here, here, here and here).

I have neglected blogging recently since I am prefer to focus on other activities, but this blog is by no means dead. Reducing the fluff and getting to the stuff. Still, I am still an avid blog reader.

I wish everyone a happy, fun, prosperous new year!

ReSharper 2.5 rulez

2006-11-07T19:07:00.000+02:00

I am very impressed with the latest ReSharper EAP build, and the roadmap looks very promising. I especially like the:

Improved find results view
Improved Control+F12 behaviour (I was a fan of Visual Assist Alt + M , but this is even better).
Enhanced context actions and quickfixes (I took a picture of numerous context actions in a single <pretty awful> .cs file)

More goodies to come! The planned performance improvements are good news since this is the single reason I sometimes turn Resharpet off.

Unimaginable, stupid bug

2006-10-22T02:31:00.000+03:00

Yesterday I had a crazy debugging session on a simple code that just refused to work. I had a listbox which I wanted to databind to a list of objects. I set its DataSource, but the listbox remained empty. So I began thinking and experimenting:

Maybe the data binding code is somehow wrong? I searched and tried at least four other approaches to databind the list - still empty.
I added the objects to the listbox items collection one by one (no databinding) - still empty.
I added a few random strings to the items collection (the simplest case) - still empty.

Debugging the code revealed that the listbox had the proper items, but somehow they were not displayed. Pure evil! I inspected every reference to the listbox to see if I messed up something without intention. I also looked at all properties related to its visual behaviour. Everything seemed OK.

In desperation I did a little experiment to try to isolate the problem - binding another listbox to another array of object. It worked fine, so I realized that the cause of the problem should be something really stupid. You bet, I was right.

There was another listbox above mine, which I had accidentally added to the form, and it was hiding it completely.

Those evil listbox was never filled with items, so no wonder it was empty. Spending more than an hour on something like this can really be a pain when you you are racing against a deadline, as it was in this case...

A Closer NUnit Relationship

2006-10-18T15:44:00.000+03:00

I had used NUnit in all of my .NET projects so far, but now I have the chance to become a superuser. We plan to add NUnit integration in our product. I won't go into much detail here, but the idea is that our application will execute NUnit test cases and the results will be saved in a format that is used in our app.

The problem that I face right now is that I hoped that I could use nunit-console to run a test case, but there is no such an option. The atomic unit for execution is a test fixture. Argh, why is this option missing? I doubt it that it was much difficult, since Zanebug console runner already has such a feature. So what are my options now:

Use Zanebug (it claims to have NUnit 2.2.7 support)
Search for a better nunit-console replacement (if anybody knows about one, please let me know, btw MbUnit console app options are very limited, too)
Develop a custom nunit-console replacement that fits our needs (probably based on nunit-console code).

I hoped I could use the standard nunit-console app, since I would not have to learn the API intricacies and deal with breaking changes in future NUnit versions, but it seems that I am screwed :)

Another problem that I can foresee, is that running multiple test cases one by one, can cause a performance problem if the assembly is loaded and unloaded on each execution. Might be a good idea to come up with a workaround.

What I have been doing for a month

2006-10-05T10:56:00.000+03:00

As I mentioned in a previous post, I use QlockWork to track my activities at work. They had just released version 1.2.0 that fixed a problem that prevented me doing reports. So the first thing I did, after I installed the newest version, was to the a report by application for the last month. Here are the results:

50% Microsoft Visual Studio 2005
15% Microsoft Outlook
8% Mozilla Firefox
6% Trillian
3% RSS Bandit
3% Windows Explorer
15% Various applications (about 30 of them)

Am I surprised? Well, I expected VS.NET to have a little more share (though it is defiinitely not my only development tool - the other 30 apps in the various section are a part of my toolbox). Spending 15% in Outlook (10% of which writing) has surpassed my estimations a little - I was expecting 5% less. And spending just 3% in RSS Bandit look like maybe I am not investing enough time on staying up current and well-informed.

Refactoring Code - How Do You Know You Are Not Breaking It

2006-09-30T12:37:00.000+03:00

UPDATE: The title of the post should have been "The Cost and Benefits of Emotion-Driven Code Improvements", but since this was an emotional and not well prepared post, I screwed it :) This is the third draft, and finally it looks understandable...

Last Saturday I felt a strange urge to go to the office and to finish what I had started the previous day. Basically I was frustrated by working with poorly formatted and commented code, that did not follow naming conventions and other good practices. I had also noticed a few flaws in some parts of the code, such as not guarding for exception between IDataReader's Open() and Close() methods (which was easily fixed by enclosing the reader within a using region) and other exception handling problems.

I thought that (in the long run) me and the whole team will be spending much more time and energy understanding such code, than the time and energy I wanted to spend to fix it. Yeah, most of the developer's time is spent reading the code. With the help of my beloved ReSharper, I reformatted all the code in one of the projects in the solution by fixing spacing, shortening references, removing unnecessary this qualifiers, removing unused code. Then I did some manual whitespace formatting and finally applied the functional fixes in the code. I did all those things in a single session intending to perform a single checking-in. And you better believe that later it turned out that it is impossible to quickly find what the functional changes were. No diff tool is that clever to show only the differences that can affect the behaviour of the program.

Lesson learned: Separate concerns, do one thing at a time, and checkin after it is completed.

I waited till Monday for the check-in, in order to get the approval of my PM, since this was not a planned operation. I was not surprised to hear that he was not very enthusiastic about such major code changes - every single file of a project with about 60 files was modified. He asked one of my colleagues to do a review of the changes. I had to explain that this is not as easy as it sounds and I offered an approach that would eliminate the non functional code changes altogether, by looking directly at the generated IL. Well, not the ugly IL itself, but better the output of its decompilation (of course, using Reflector).

I remembered that there is a Reflector addin, called Reflector Diff. It works very well, but only on per method basis, so it was virtually impossible to inspect all functional changes in a reasonable amount of time. We ended up using a statistical approach, examining just a couple of files and generalizing about the quality of the changes, heh :) Later I got some better ideas, but it was too late: (a) Decompile the old version and the new version of the assembly in separate folders with Reflector.FileDisassembler and diff them with a tool that supports folder diffs (like my favorite WinMerge). (b) Automatically reformat the old code with Resharper and then diff all the files in the folder.

Lesson learned: After making a mistake, there is often still a chance to find a good enough workaround. So know your tools and use them creatively.

After my code changes got approved, I tried to check-in them. Surprisingly it turned out that 3 of the files were already modified by other people and I was faced with the difficult task of merging them. I am not sure how this happened, I am pretty sure that when starting editing a non checked out file, VS.NET takes care to get its latest version before checking it out.

Unfortunately these were one of the files with the most functional changes in them. The automatic VSS merge naturally could not handle such major changes, so I had to perform it manually. What I did was to find out what the other people's changes were and apply them one by one. I had to be extra careful, so it took two more hours to get it done.

But there were more surprises in store. During the checkin process I was shown the default VSS merging screen to merge the changes. I knew that the current state of the files was already up-to-date so I chose to Apply all the changes from the right pane. Argh, hete it get very confusing, because it turns out that this operation does not copy the whole file to the merge result. It appears to do something different, so I ended up having a few unused methods in the result files, that were deleted in my version.

Lesson learned: Know in detail the behaviour of the tools you use, unless you like surprises :) When starting a major refactoring make sure that noone else is editing the code.

Aftermath: I think the mission was a success. Why?

I can now work on a codebase that makes me feel comfortable and productive.
I learned a few things along the way that could help do better the next time I have to clean bad looking code.
I had a chance to show my colleagues the power of ReSharper, my standards for good code, and what was the state of our code base (btw, this was one of the best designed and documented parts in the solution). I guess that I should have done that a while ago. In fact I proposed such a course of action few months ago, but I don't think that I pointed clearly what the benefits were. But when people dwell in clean code for some time and see how good code feels, they realize that they don't have to work in the mess, so they are ready to make the necessary effort to do so.
Finally, I was really amazed how productive and energetic I was, when working on something I thought would make a difference.

Atlas Woes

2006-09-19T19:06:00.000+03:00

Today was my second attempt to employ Atlas in the ASP.NET project at work. The first attempt was before my summer vacation when I tried to modify the Login page to use CascadingDropDown which is a part of the Atlas Toolkit. For a day and a half I could not get it to work, but at least I got acquainted with Atlas. I eventually figured out what the problem was and it was not Atlas-related. While filling the drpdown for the login info, I was trying calling a web service that redirected me again to the start of the login process :) No wonder I couldn't get it to work.

Today was my second battle with Atlas - again using the CascadingDropDown, but on a different page. This experiment was meant to be simpler than the previous one but it was actually harder. Unfortunately I was getting the cryptic error "Unknown Error" in IE6. I had no idea what it meant, but after some googling and numerous experiments, it revealed to be Atlas related issue (if the EnablePartialRendering is set to false, the problem does not occur).

After more googling I found this post and in the comments I noticed a few good tips how to deal with such a problem. I better copy&paste them (with a little rewording to clarify them):

1) Replace Response.Write() with this.Page.RegisterClientScriptBlock(function)
2) Put complex javascript functions in CDATA sections.
3) Check syntax of html, css, javascript
4) Remove characters that cause invalid XML output
5) Try to build pages sometimes with UpdatePanel or sometimes with web methods in aspx page with the use of atlas.js file & javascript functions to call those web method without page refresh.

I am still not able to find the exact place where the error occurs in the page, but now at least I know where I should focus. UPDATE: After spending another half a day trying to resolve the issue, there was no progress at all. We decided to postpone Atlas adoption in the project (probably until the release of an official version). I actually feel good about such course of action. Now we can spend more time on other areas of the product that will make greater difference than a few eliminated postbacks :)

Question: How Do You Know Your Windows Is Getting Overwhelmed?

2006-09-18T16:54:00.000+03:00

Answer: When the Start menu fits in 4 columns (I wonder how 5 columns can be displayed on the screen).

P.S. My relief is that I almost never start programs from the Start menu - Launchy and Slickrun are really helpful.

Spying on myself

2006-09-14T14:51:00.000+03:00

In the last two months I have been trying out a few programs to record my activities at my computer at work. The first one is TimeSnapper - which takes snapshots continuously while I am working. TimeSprite and Qlockwork are applications for recording the active application and document each N seconds. Later the data can be grouped and visualized as a list, charts, calendar activities.

These tools proved invaluable today when I noticed that I have not been filling in my daily report for about a month (oops!). I quickly turned back time (this reminds me about the Time Machine feature in the upcoming new Mac OS) to find out how I was spending these days. In less than 15 minutes may report was done and was actually pretty accurate. Another benefit for me in using such applications is to become more aware of my working habits and to track where my time goes.

I would recommend using a combination of TimeSnapper (see why/how Jon Galloway is using it here) plus one of the two other applications. I am currently using a beta version Qlockwork, which has some rough edges, but its MS Outlook integration is pretty slick and useful. The good thing is that those apps require non of your attention, unless you want to track not just the active documents, but also the current project you are working on (then you have to set it when switching projects).

P.S. Ha, I didn't know there was a movie with the same title as my post.

What a work-week

2006-08-26T17:27:00.000+03:00

This week was a very untypical week. Just back from a one-week vacation, I was faced with the opportunity to work on two projects in parallel. I was continuing my commitment to the big ongoing project I am working on and I was also asked to enhance the little surprise project that I did a few months ago. When I had to make an estimation, I gave a 8 workdays figure.

This week I was having 2 hours overtime each day and now I am spending the Saturday at the work place. The good thing is that the job is almost done. The funny thing is obviously that it got done for 8x2 hours instead of 8x8 hours. Am I such a bad estimator or was I overly cautious about unexpected difficulties (well, they happen in nearly every single project). I guess when you work on your own code only, when the tools are right, when you understand your objectives and the client is responsive and well-meaning, when you are motivated to make it work, it doesn't take that much time.

Generally I don't like doing overtime. And no, that's not because the Pope says its wrong - it just feels wrong at the end of the day, or at the end of the week. Hopefully at my job this doesn't happen often, so I can live with it. But if I decide to do it, I find it helpful to shift my focus on how I am making the lives of the project stakeholders better (the client and my boss) and about the opportunity to entertain myself switching tasks and last but not least the financial rewards. And finally it gives me a topic to write about and clear the cobwebs from my blog and to test the wonderful Windows Live Writer :)

Tweaking Performance - Magic Moments

2006-07-27T16:53:00.000+03:00

Every once in while a developer experiences magic moments. Yesterday I had one. A colleague of mine and I were struggling to improve the performance of a data exporting module of the system. First we tried to measure how bad it is, to give us a baseline. With small amount of data the export took 5 minutes, but with 10 times larger (real world volume) it took forever. On the first attempt after 14 hours of running it had not yet finished and we had to stop it. On the second attempt (on a more powerful machine) it exited within a few hours with OutOfMemoryException. So, our first priority was to reduce the memory demand of the application.

Initially we started with memory profiling, trying out several commercial profilers. Unfortunately we didn't achieve any clarity (I wonder whose fault is it). So we decided first to think about the code for a while, to analyze what was going on. We refactored parts of it to understand it better and see the big picture. While doing so, we spotted and fixed a few little annoyances, that caught my eye, and then we concentrated on the big issues. We tried to reach a common understanding about the bottlenecks and the ways to remove them, but I think we got caught in analysis paralysis. None of the ideas seemed worthwhile and the more crazy ideas needed big codebase rework. So in order to reach better clarity, I proposed to get away from it for awhile, and to check how the little fixes we did, affected the performance. My guess was that we had made minor memory and speed improvements. When we executed the small volume data test, it took not 5 minutes, but 20 seconds. Then we tried the real-world test and instead of running for many hours (14+) it completed in just 3 minutes. We stared in amazement and wondered whether we could start celebrating. It seemed too good to be true.

Today, first thing in the morning, I started a performance profiler on the old version to find out what was slowing it down (I know, I should have started from there). I found that the 90% of the processing time went for concatenating numerous big strings. This was done the wrong way (i.e. s1 += s2). Switching to StringBuilder made a huge difference, but we could actually do without it: the strings just had to be written in a file and there was no need at all to keep their concatenation in memory. There were a few more things we did to reduce memory, but still trying data that is 3 times the size of the expected real-world volumes gives an OutOfMemoryException. Let's see if we could tweak it more.

Improving .NET application performance

2006-07-19T11:53:00.000+03:00

The last two days I was involved in a somewhat unusual activity - detecting, measuring and clearing performance bottlenecks. I have no real experience in this area (well, recently I diagnosed a performance problem, but it was too obvious - excessive logging in a file, while opening and closing it on each call). So it took some time to familiraize myself with the topic and to try some .NET profilers - JetBrains DotTrace and CLR Profiler. Unfortunately JetBrains DotTrace (EAP version) did not help me much - I was having difficult time trying to understand how it works, since the documentation is really scarce at this point. It also crashed while trying to make huge memory dumps (1 GB), so I gave up on it. I looked at Red Ants Profiler video and it seems a bit better for a newbie, but I have not used it for real, so I can't tell. The CLR Profiler is not a gold-plated tool, but it worked fine and was actually somewhat helpful.

Today I was trying to find out which worked better: (a) File.ReadAllText() or (b) calling first File.ReadAllBytes() and then converting them to char[] and then encoding them as UTF8 string. Interestingly, inspecting WorkingSet and GC.GetTotalMemory(false) indicated that the used memory was less after File.ReadAllText(). But the CLR Profiler showed that it has allocated more memory. I wonder how this is possible? Am I measuring the wrong thing or maybe some garbage collection takes place within File.ReadAllText(). The (b) approach is a bit faster than (a), so I ended up using (b).

UPDATE: actually the (b) approach will not work that easily. There are a few marker bytes in the beginning of some text files that indicate the encoding, so you need an extra processing to make it work.

Btw, it appears that it is not a good idea to profile .NET application memory using just the the TaskManager. More details here.

Code Complexity Fun

2006-07-03T18:59:00.000+03:00

I am starting working on a class that looks cute. Especially two of its functions are especially nice:

Func1 - 9 arguments, 300 LOC

Func2 - 15 arguments, 1000 LOC

I had not met a 1000 LOC function for a few years, so it is fun to see one again :) It even has a parameter about the GuiMode, which tells if it is called in a GUI context or not :) They don't come often better than that :)

UPDATE: This gets even funnier: Func1 actually used only 2 of its 9 arguments. Func2 had only 4 unused parameters... :)

XML Serialization

2006-07-01T12:11:00.000+03:00

In the recent days I have been trying out .NET XML serialization with the XmlSerializer class. It has a plenty of limitations (such as not supporting Hashtables, serializing only public properties, etc.), so I find it useful only for simple scenarios. There are available other custom-made alternatives as CustomXmlSerializer that look useful. In fact, the default xml serialization can be customized using the interface IXmlSerializable. Unfortunately the xml serialization that is implemented throughout the codebase makes it hard to work seamlessly with the .NET default serialization. And I guess it is not worth the effort (plus there surely is a little performance penalty using reflection).

Desktop search tools

2006-06-29T00:17:00.000+03:00

It seems that I will be switching to a new desktop search tool. X1 has released their enterprise client for free and it looks pretty useful. It is similar to Yahoo Desktop Search that I had used for a while (it was built on top of X1) but the original X1 tool has several advantages. It is more customizable and powerful than any of the tools I have tried (MSN Desktop Search, Google Desktop Search). The only things that I don't like about it are:

missing full unicode/cyrillic support (I can't see any Bulgarian filenames in the results grid)

missing the standart Explorer context menus on files in search results
missing integration with other tools (e.g. with MSN Desktop Search + FolderShare I can search my computer from any internet-connected computer)

But the powerful search capabilities, the great GUI, the ability to search network shares (oops, the network shares are available in the commercial version only) are too compelling reasons to change.

Btw, a good resource on desktop search tools can be found here. It seems to be regularly updated and can help you decide which tool
best suits your needs.

Microsoft DevDays 2006

2006-06-22T18:43:00.000+03:00

These couple of days I went to Microsoft DevDays 2006. The topics of the lectures I attended were pretty interesting - Windows Vista, .NET 3.0 (WCF, WPF, WWF), Software Factories, MSF 4, VSTS for Testers.

Windows Vista is pretty exciting, offering a lot of improvements in many areas (well, and some potential annoyances, too).
VSTS for Testers was an interesting lecture for me, since the project I am currently working on, offers similar functionality. My team even attended a QA seminar last week to get a better feel of the problems of automating testing and the tools available.
MSF 4 looks interesting, too, especially the Agile part. I think that the practices are more important than the tools, but good tools can definitely help (although VSTS is a bit awkward on demos).
WCF, WPF, WWF - all these things are pretty exciting and definitely have potential. I especially liked the lecture discussing building www.msbgregistration.com using these latest technologies. It was probably the best talk, since it covered a real world example with new technologies and inspired a good Q&A session.

Overall the event was nice, though there were a few organizational aspects that were not very well thought of. I guess I would go the next year, too. And I will definietly go back to Arena cinema, where the conference was held, having two movie tickets to spend :)

I knew the project would be fun

2006-06-15T16:48:00.000+03:00

When I started working on my new project a month ago, I noted that it uses great variety of technologies, so I wouldn't be bored to death. Now I know I was right. The first month I did mostly ASP.NET development, which was interesting since my experience with it was very little. In the begining there were a lot of small frustrations here and there, while figuring out why some things misbehave, but those moments are now very rare.

In the last two days I did some totally new things for me. Yesterday it was XSL transformation (VS.NET 2005 helped a lot there) and today it was Ajax. The Ajax thing was powered by AutoSuggestBox and even though it was not a rocket science it felt refreshing. I was implementing a search-as-you-type functionality. It was of the simplest kind: just find those names who start with the input letters. I wonder if we should make it powerful like Resharper's Ctrl+N but since the product is not intented for developers, it might be better to stick to a simple way.

VS.NET too clever

2006-06-11T21:58:00.000+03:00

VS.NET 2003 has a bit confusing feature in the Solution Explorer. It groups three files as one : the asp.net page, the code-behind file and the .resx file. I have not found a way to turn off that clever option (UPDATE: actually there is an option "Show All Files", which I will be definitely using, see a picture here).

So I got burnt today by this feature when I was editing a code-behind file. I was not sure what I had checked in, so I wanted to see if the local version was different from the VSS version by clicking "Compare versions". I was informed that there are no changes and I did an undo checkout operation. Then I realized that I have been comparing thes .aspx file and not the .cs file. Argh! I spent another 30 minutes or so redoing the edits. On the good side: the edits turned out even better than the first time. It is a good practice to throw away some code after it is initially written and start it all over.

P.S. I wonder why I can't find a tool that backups all the pending checkins in VS.NET. This is definitely something my colleagues and I would like to use, since a little mistake with VSS can lead to loss of code. I have the feeling that a simple macro might do the job, but I am not sure if this functionality is covered in the extensibility. Also, the Pending Checkins window could become a lot more useful, if the context menu on its files, included all the options that are available in the Solution Explorer (VS.NET 2005 seems to solve at least partially this problem).

ASP.NET chapter completed

2006-05-30T09:20:00.000+03:00

Yesterday I did the last revision of the ASP.NET chapter of the Bulgarian .NET book. It turned out to be about 100 pages and I guess it could well be 10 times bigger. I realize that we can cover only the basics of ASP.NET development, but I think that the chapter gives a good overview of the topic. Since the chapter was developed in parallel by four people before I took over for the final edits, there were a lot of stylistic inconsistencies and repetitions and so on. It took several revisions to take care of them, but now that the content is pretty consistent and the information flows in a way that makes sense most of the time. Well, there are still some rough edges, but better release something now than wait forever. The second volume of the book could have been out a few months earlier. Now .NET 2.0 has gained a lot of momentum and writing about .NET 1.1 will have very short-term value, though in reality a lot of projects that were started with .NET 1.1 might never transition to .NET 2.0. I am pretty happy with volunteering for this chapter, since now the second volume can be at least uploaded online and sooner or later the printed edition will be released.

Firefox Configuration Revisited

2006-05-28T23:38:00.000+03:00

It has been a while since I posted my Firefox configuration, so let's do it again (btw, this is might config at home, which is slightly more crowded than the one at work).

Generated: Sun May 28 2006 23:31:24 GMT+0300 (FLE Standard Time)

User Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.3) Gecko/20060426 Firefox/1.5.0.3

Build ID: 2006042618

Enabled Extensions: [32]

Adblock 0.5.3.042

Add N Edit Cookies 0.2.1.0

All-In-One Sidebar 0.6.4

Blue Frog SRT 0.722

BugMeNot 1.3

Compact Library Extension Organizer (CLEO) Beta 1

CustomizeGoogle 0.48

del.icio.us 1.1

DownThemAll! 0.9.9.3

dragdropupload 1.5.11

Fasterfox 1.0.3

Firefox Extension Backup Extension (FEBE) 2.0.1

Gmail Manager 0.4.3.6

Greasemonkey 0.6.4

IE Tab 1.0.9

Mouse Gestures 1.5

Mozilla SpellCheck Libraries 1.0.1.0

MR Tech Local Install 5.0.3

Paragrasp 1.10

Paste and Go 0.4.3

PDF Download 0.6

Performancing 1.2

Searchbar Autosizer 1.1

SpellBound 0.7.3

StumbleUpon 2.77

Tab Mix Plus 0.3.0.5

Talkback 1.5.0.3

ToCyrillic 0.5.5

Update Notifier 0.1.2

Viamatic foXpose 0.3

Xinha Here (Firefox 1.5 edition) 0.4

Yahoo! Mail Notifier 0.9.9.2

Disabled Extensions: [2]

Leak Monitor 0.2.0

Reveal 1.0.6

Total Extensions: 34

Installed Themes: [2]

Firefox (default)

Qute 3.1

Installed Plugins: (13)

Adobe Acrobat

Java(TM) 2 Platform Standard Edition 5.0 Update 6

LogMeIn Inc. Remote Access Components 1.0.0.236

Microsoft® DRM

Mozilla Default Plug-in

PCMan's IE Tab Plug-in for Mozilla/Firefox

QuickTime Plug-in 7.1

RealJukebox NS Plugin

RealPlayer Version Plugin

RealPlayer(tm) G2 LiveConnect-Enabled Plug-In (32-bit)

Shockwave Flash

Shockwave for Director

Windows Media Player Plug-in Dynamic Link Library

ASP.NET gotchas

2006-05-23T19:23:00.000+03:00

Yesterday I was hit by two gotchas in ASP.NET.

The first one was about the Visible property of a control in a UserControl. I wanted to switch between showing a grid and a label with text "no data available", depending upon the number of records extracted. So I just typed:

grdXXX.Visible = (records.Count > 0);
lblNoRecords.Visible = ! grdXXX.Visible;

But the visibility lblNoRecords never changed when testing with and without records. First, I made sure I don't change it any place else. Then I debugged it and it appeared that when grdXXX.Visible was false, after setting lblNoRecords.Visible = true, the debugger showed that lblNoRecords.Visible is still false. I was really intrigued, and after some futile experiments I fired up Reflector to see what the Setter and the Getter did. I realized that even though I set the Visible, the label was not visible, since the UserControl container was not yet visible. Then I figured out that grdXXX.Visible returned always false, so that's why the label was always visible. The simple fix was to change the second line to: lblNoRecords.Visible = (records.Count == 0);

The second gotcha problem was when I wanted to populate a data grid dynamically when handling the EditCommand. I succeeded to add a few textboxes for the user input in one of the cells of the edited DataItem. Unfrotunately in the UpdateCommand handler method none of those were available in the Controls property. I realize this has to do with them not getting in the UserControl's ViewState, but I am not quite sure how to put them there, so that I can access their propertes later. I wonder if it is possible to add them to the ViewState, or do I have to use some client-side code for a workaround?

UPDATE: The second problem had a pretty simple workaround with this excellent DynamicControlsPlaceholder control. For those like me who don't understand control lifecycle well enough, this is an excellent time saver.

Review of JustCode 1.1

2006-05-19T00:02:00.000+03:00

Roy Osherove reviewed JustCode 1.0 about half an year ago. I think most of the pros and cons of JustCode described in Roy's review are still valid for the 1.1 release. I have a few comments to add, but have in mind that 30 minutes of working with the product are definitely not enough to give it a fair evaluation. And my point of view is that of a ReSharper addict, who wants to keep all of the goodies of the JetBrains' product and eager to have more.

My overall opinion is that JustCode is good product, but in many ways it can't compete with ReSharper.

One of the good things about it is that it seamlessly integrates in VS.NET 2003 (so seamlessly that it is not in the Add-Ins list, so you have to go to the general Options dialog to turn it off/on and tweak its options).
First thing I noticed after starting it is that its memory demands are close to those of ReSharper, sigh... It showed a lot of errors in the solution after parsing it, but most of them were definitely not real errors. Those fake errors included some HTML ones, some concerning types defined in referenced assemblies, etc. Hopefully one can ignore all the errors that he decides, so they don't show up in the IDE.
The refactoring support is good enough. It covers the most common scenarios and I liked the dialogless approach. I can't say that it is very reliable though. I tried a rename on a Web control and it worked the second time (the first it asked about opening files that will be edited, but did not applied the refactoring only to the codebehind class).
The navigation functions are pretty good, especially "go to symbol by name" might be very useful, though the UI is not very slick.
The code templates were not very impressive, but there are some useful ones.
I liked the feature "learn code style from file", though the C# code styles options are more limited than ReSharper's ones. But the valuable thing about code style is that it is not only about C#, but also VB.NET, HTML, ASP, Javascript and automatic formatting of the code can be applied

JustCode gives VS.NET a nice boost, and if you are not ReSharper junkie, you might enjoy it quite a lot. Unfortunately, using them side-by-side is really not a viable option... so ReSharper wins (again).

VS.NET Productivity Add-Ins Revisited

2006-05-18T00:14:00.000+03:00

I posted some links to VS.NET 2003 productivity add-ins a while ago and now I need to catch up.

ReSharper has continued to be my tool of choice and I have become quite profficient using its numerous features. Well, it is not perfect - its memory consumption is high and some operations are really slow, but it makes my coding very hassle-free.

I found that Visual Assist X is a good complement to ReSharper. The nice things about it are that it has great intellisense (fast and powerful, though a bit hard to get accustomed to), it offers spellcheck, and supports not just C#, but C++ and VB.NET too. Its requirements are not heavy, so it is great for big solutions. The syntax coloring is also interesting, though I have get used to ReSharper's way. The dark side is that sometimes VisualAssist gets unstable and misbehaves, but such are the risks of the trade.

I just saw that JustCode has released a new version 1.1. The feature comparison between it, ReSharper and CodeRush looks very promising and it makes me think that Resharper could have been even better. I had given a look at the Omicore IDE (X-develop) a few months ago and it made good first look impression, though it had a few rough edges. So JustCode might be worth a try. I don't think that it would be reasonable for me to try to replace ReSharper, but if JustCode is faster and reliable, I might be converted.

I notice that the number of refactoring add-ins increase with CodeIt.Once. After seeing a few screenshots in the documentation area, I cannot say that I am not hooked up. It has some nice wizards, that might be very helpful for those who are not quite familiar with refactoring practices. In the comments section I added a few more comments after I tried it for real.

Visual Sidekick has recently released a new version but it is all about navigation, and there Visual Assist X offers similar features like Symbol Search, so I am not really despearte about such a tool.

UPDATE: I did a quick review on JustCode in a new post and in CodeIt.Once in the comments section. Both seem to be good products, especially if you are not coding just in C#, but I will stick to ReSharper for now.

ASP.NET components on DNR TV

2006-05-15T15:14:00.000+03:00

The DotNetRocks TV show featuring Adam Cogan talking about ASP.NET components was pretty cool. I am relatively new to ASP.NET development, so I have little (nearly none) experience with third-party controls. Adam did a great job demoing and evaluating various components from the major vendors like telerik, Infragistics, ComponentArt etc.. If you are planning to use advanced controls in you ASP.NET development you should watch it. I don't think that his review was 100% thorough and accurate, but it was definitely interesting. One of Adam's observation was definetly inaccurate. He said that telerik radTreeView did not offer context menus, which might have been true a long ago. But if it didn't offer such menus, last week I would not have hunted for a bug concerning the rigth way to use its context menus. I have to thank a friend of mine, who works at telerik and was eager to assist me into solving the problem quickly. It turned out that I was looking at a piece of an outdated documentation.

Replacing Windows Programs

2006-05-10T20:12:00.000+03:00

I am pretty big on replacing default programs that come with Windows with better ones. Many of everyday frustrations disappear with a proper replacement.

I just replaced my notepad.exe with notepad++. I have been using this editor for a few months and it is definitely the best notepad replacement I have found so far. It is amazingly light and powerful and I use it for text files, xml files, code files (c#, asp) etc. The newest version 3.5 got some cool facelift, so it looks pretty nice.

I was also researching a couple of weeks ago an Explorer replacement. I mean Windows Explorer, not Internet Explorer (I hadn't used IE for ages, but currently my role is a webdev so I have no choice). WinExplorer sucks very much indeed, it is missing numerous functions and is really slow (because of IE integration and extensions). I stumbled upon a great discussion which is its best replacement. Many people are fond of TotalCommander but it is very ugly. The better replacement IMHO is XYPlorer and I am trying its trial. Though it had recently become commercial, there is a still an old free version available. Unfortunately I don't think it is possible for any third party program to complete replace Explorer. I mean, when an external program tries to open a directory to run something else instead of WinExplorer.

What else? Hmm, yeah, the default unistaller "Add/Remove Programs" of Windows is terrible. I have tried a trial of Your Uninstaller which was great, and I currently use the free MyUninstaller which is not that great, but is way better than the windows default.

Well, I can think of many other replacements I have made in the quest for the perfect computer environment. But those were the most recent and noteworthy ones. Worth taking a look!

Speeding Up Development In a Big Solution

2006-05-10T12:57:00.000+03:00

Yeah, it is nice to speed the build from 100 seconds to 5 seconds, and that's what I did by moving from project references to file references in an ASP.NET 1.1 web application project. I created a copy of the project file, manually edited it and set a W: drive as a hint path for the file refernces. Then created put it in a new empty solution and that's it. You can see some more best practices here.

But what is the hidden cost:

No easy way to navigate and view the source of the referenced libraries. While investigating code and debugging this is a real issue.
If the libraries beneath change, the update is a several-step process instead of 2-step (Get Latest Version and Build).
There is a need to sync the files in the project references project and the file references project. That seems trivial cipy&paste, but one can easily forget about it.

The good part is that everyone can choose which solution to work on. I was thinking of the idea to have to instances of vs.net side-by-side and choosing the one that is more appropriate for the task at hand, but that defies one of the positive impacts of having lower RAM consumption.

Ideas for speeding up work

2006-05-05T19:10:00.000+03:00

I complained yesterday that working in a large solution and in a large asp.net project is pretty slow. The initial time for loading of the solution is negligable compared to the time to build, which is more than 2 minutes. I am used to really fast builds and immediate feedback and I want to make as fast as possible. I wonder if it is a good idea to separate the web project from the solution (and use file references instead of project references). I guess that it will be much more easier for the build and for Resharper. Well, there are some shortcomings:

I lose the ability to quickly move around all code - not good, but I may just navigate to individual files, outside the solution.
I can't do solution-wide refactoring - well, I am not supposed to do such things while I am a noob in the project.

Still, it might prove worthwhile, I just have to test it.

Another problem is that I am used to make small changes and immediately check in the modified code. But the workflow in the project is not always that simple. Apparently sometimes we are not supposed to do check ins for extended period of time. This brings some risk, though, because I might lose code if VS.NET crashes or my harddrive fails. Hmm, I wonder if it is a good idea to use another intermediate-stage source code repository and to sync it every few days with the main VSS repository. I am thinking of using Subversion for this task, since it has definite advantages over VSS (I just hope that AnkhSvn is more stable in VS.NET 2003 than it is in VS.NET 2005).

Another related issue is what VS.NET 2003 addins to stick to. I really need Resharper for a lot of routine tasks, but I seemed to like VisualAssist too. Unfortunately they don't play perfectly with each other so I might have to switch between the two. The problem is that VisualAssist misbehaves when I try to load/unload it and I don't understand why its menus remain inactive when I manually activate it.

It will be nice to set up a very productive environment, since I will work on this project for a long time. Environment alone will not solve all the problems, since my web development skills are not very strong and I have a lot to catch up in the project. But progress is made a step in a time, so why not start with the environment.

First Impressions Of The New Project

2006-05-04T22:53:00.000+03:00

Well, I finally am working on software that fits in the category of enterprise solutions. The codebase consists of 40+ projects written in C#, VB.NET and C++. There is desktop, web, remoting stuff - vast breadth of technologies. It look like it can not be boring!

I am starting with the ASP.NET application which is pretty huge. There are bunch of third party controls that we use and a lot to learn. After two days of acquainting with the codebase I notice that a part of it is very well documented (in particular the API libraries). Some thought has definitely gone in the design, but I am can't tell how usable the API is, I don't make fast progress with my first attempts. There are a lot of concepts in the system and it is hard to understand the big picture.

The quality of the source code varies a lot. I have seen some very good looking code (meaningful names, well-documented, well structured), but I have seen some a lot of fragile code, especially in the web application. I have met instances of code dupliication, copy&paste programming, over-reliance on strings, bad english, unhelpful naming, magic numbers, inconsistent coding conventions. There were some good WTF gems here, heh. But it could be much worse.

The size of the codebase gives me some uneasiness. It gives ReSharper some tough time and devenv.exe memory reaches 300-400 Mb. I decided to give VisualAssist a try, since it supports C#, C/C++ and Visual Basic .NET. Although I liked many of its features and its performance, there are some issues/bugs, that makes it a bit untrustworthy. I realize my addiction to ReSharper is overwhelming, when I work without it, there is something missing. I have to come up with a workaround, otherwise my productivity and enjoyment will drop significantly.

Consolas fonts for programmers

2006-05-04T18:53:00.000+03:00

I have been following for months a lot of online conversations and rants about the value of progammer fonts, but I had not bother to try them. Today I proved to myself that I am a programmer by installing Consolas and setting it as the font for VS.NET and ReSharper. It looks pretty good. I really needed such a programming-identity-boost, since today I could not get any code to a functional state, heh. Why? Well, this is a topic of another post, coming soon...

ASP.NET In Action

2006-04-30T21:47:00.000+03:00

It seems that my preparations from ASP.NET will not be pointless. Next week it is highly likely for me to start in a long awaited ASP.NET project.

The last few days I also had a chance to use my (limited) knowledge in this area to become an editor of the last pending chapter of the Bulgarian .NET book (part one of the huge ASP.NET topic). The document was at a pretty rough draft stage when I got it and although I made a lot of progress in a couple of days, there are still a lot of incompleteness and rough edges. I hope to finish it quickly, since it has been the bottleneck for the release of the second volume of the book.

Touch Typing From a Two Months Perspective

2006-04-27T18:15:00.000+03:00

I last blogged about touch typing more than two months ago when I completed my training in it. This week, while listening to some podcasts in front of the computer, I decided to fill in the time with a bit multitasking. I could not do anything else that involved thinking so I fired Stamina to test my typing speed. I wondered how will it compare to my scores two months ago. Has it become a habit? It appeared that it has and all my scores were in the 305 range (+/- 10). Today I even topped my personal best doing 324 CPM with 4.8 % errors, while not concentrating fully on the practice. It seems that I have fully embraced this skill and I no longer have to look at the keyboard.

Killing processes is not that easy

2006-04-26T13:06:00.000+03:00

I am having a weird problem. I cannot kill a process (in fact two of them, sigh).

I see them in the TaskManager, I choose 'end process' and ... nothing happens.
I run ProcessExplorer from SysInternals, click 'kill' and.. nothing happens.
I use taskkill from the command line and ... nothing happens. (even with the \F parameter)

Come on, ain't there any other ways to kill a process? Those are not some special system processes, these are my own creation. Just two simple apps that talk to each other via a (virtual) serialport. Actually, they are in one and the same assembly, that has copies in two locations. I start them with different command line parameters, but these facts don't make them special in any way. I wonder if the problem is with the .NET framework (I use .NET 2.0)? It might be some finalization stuff? But since they are processes, I should be able to kill them with all the common tools.

Who should I ask for advice? Probably the Ninja Master might do a little show on the question "Do ninjas kill processes that common people and tools can't?". I am sure he will end his rant with his usual "Thanks for the question Ivan, I am looking forward to killing you soon!" :)

Some Pointless Blog Reading Stats

2006-04-21T18:19:00.000+03:00

I was wondering what and how I have been reading in my RSS aggregator, so here are the stats:

Feeds - about 130 (the list is in a constant state of changing)
Posts - about 50 daily (65 on workdays and 25 on weekends)
Signal-To-Noise-Ratio - I guess between 15% and 25%
Hours - 30-60 minutes per day (on busy days they might be zero)

The moral? To Be Determined! :)

Subversion-AnkhSvn problem

2006-04-20T18:49:00.000+03:00

As I have been happily using subversion for 3 weeks, today I was hit by an unexpected error. AnkhSvn complained something about "subversion reported an error", "xml parser failed", "unclosed token". I fairly quickly tracked the problem down to a corruption of the entries file in one of the subdirectories. TortoisseSvn confirmed my assumptions by not showing a special icon on the folder (apparently it could not find out it was a version-controlled folder).

It seems that AnkhSvn has copied a part of a resx file in the entries file (I have noone else to blame, and I would not have done by myself) . I know, I know, I have been warned that AnkhSvn is a bit buggy at this stage of its development, but it is so nice to do everything without having to leave the VS.NET IDE. Next, I wanted to recover the entries file, but I could not find any online resources on how to do so, so I decided I might be able to handle it by myself.

I tried to "Svn Checkout" the problematic directory but it failed. It appeared to contain two files with the same name differing only in the case of a single letter. Well, I renamed the older one and got a good version of the entries file. Now I wonder if it is safe to just replace the corrupted file. This might not work so smoothly because some of the entries will have incorrect statuses and timestamps. So I have to backup before trying to work again with AnkhSvn. Let's see what comes up!

SerialPort troubles

2006-04-20T17:29:00.000+03:00

I had some hard time recently while trying to find the source of a problem with serial port communication. When the other side sent a few bytes (e.g. 55-11-22) an event was raised and the AvailableBytes count was 3. But the Read(...) method read only the first byte and the others were zero. And this happened only on the customer's site who used a USB-RS232 adapter, so I could not reproduce it on my machine. And there was a simple solution: give up reading all availble bytes at once, and instead call N times ReadByte(). I suppose that the USB-RS232 adapter was buggy, but I am not quite sure why the workaroung works, maybe it was a caching problem.

Looking for a good free .NET charting library

2006-04-20T17:15:00.000+03:00

I was looking for a free .NET charting library and I stumbled upon NPlot, which wiki looked promising. There was sufficient documentation to get me started, but unfortunately many problems appeared while using it for real.

The download of NPlot included a demo project which demonstrates some very interesting features of the library. But the code quality was not very high and unfortunately this applies to the library itself. ReSharper did not need more than a second to show plenty of warnings and later I investigated some methods which were pretty long and the variable naming was not very helpful.

I needed to use a StepPlot class to draw a step-looking chart and I had a few surprises. The first thing was how to set data. Until I looked at the source I could not figure this out because the property was of a generic object type. Next I had some strange problems when some parts of the chart were not drawn (possibly a bug). Next I succeeded to reproduce a bug when trying to add a single value to the chart and I submitted it here. There I saw another bad sign - the bugtracking system was empty. All widely used projects have bugs, while no one bothered to submit any for NPlot (and it is definitely not bug-free).

Now I am wondering if I should continue with NPlot or seek for another solution. My next choice should be probably ZedGraph - it's wiki is more content rich and it was promoted in a CodeProject article, but I don't think it has built-in Step-chart functionality, though I think I could easily simulate one using a linear chart.

I could also plot something by hand, but I don't think I should be reinventing the wheel. In my previous project, one colleague of mine did so. His code was very easy to understand and extend but at least there was no need to learn a framework (well, you may want to learn GDI+ first, which is not an easy task either).

UPDATE: Actually I continued to use NPlot and though I gave up on the StepPlot, it was no brainer to simulate it using a LinePlot.

VS.NET 2005 Woes

2006-04-05T16:49:00.000+03:00

To be honest there is a lot one could like about VS.NET 2005, but I had a few experiences with it recently that were not very pleasant. Today I was surprised to see Configuration Manager disappear and I could only build release assemblies targeted for the wrong platform :) Some settings got somehow messed up so I had to erase all my customizations to see the desired dialogbox again (I was lucky I stumbled quickly to this workaround) and get things back to normal. The VS.NET addins aren't mature and stable enough:

ReSharper still has some minor problems (nevertheless I can't live without it)

AnkhSvn is a still a bit buggy (I am lucky I need it only for very simple scenarios, since I am working solo)

~~TestDriven.Net busted the IDE a few times when debugging TCP sockets (It might not be the TestDriven.Net but the very IDE, who knows)~~. UPDATE: The problem was maybe completely different. Initially the project I wanted to debug was a class library (now it is a console app) and when I started it with TestDriven.NET, TD.Net had updated some project settings (test with an external program with specific command parameters). Later when I tried to debug the project with the standart 'Debug' -> 'Start new instance' the IDE tried to launch TD.Net and something was causing a crash. Now I changed the settings in 'Project Properties' -> 'Debug' it seems to work fine.

The good things about the VS.NET are definitely the better debug experience and a few useful enhancements here and there, that I got quickly used to.

Source Control for VS.NET 2005 Project

2006-03-28T13:14:00.000+03:00

I am not keen on using Visual SourceSafe for my new VS.NET 2005 project, but I don't see any better alternatives for the moment. I really wanted to try subversion with the support of AnkhSvn, but Scott Hanselman's comments about the current version of Ankh as "scary alpha stuff, use at your own risk" and I am not eager to try it. A bad omen was that when I created a new VSS database and tried to connect to it, the VSS client complained that the um.dat file is corrupted. Another viable option is a single-user Vault, but I read the source-control integration is a bit slow, and there is the overhead of installing a MS SQL Server database on the server, which is currently a bit problematic.

Logging for .NET 2.0

2006-03-28T13:07:00.000+03:00

In my last few .NET projects I didn't use any logging libraries. I just employed Debug and Trace classes to the information/warning type of logging and for the exception logging I implemented a simple file and database logging. This approach worked fine, but now I think about using a logging library to make the process more flexible and easy. I consider using log4net or NLog. The strange thing is that I don't see anywhere in their documentation if they support .NET 2.0, (I guess they do, but I would rather see it written down). Log4net is far more mature framework, but NLog seems nice too. It actually resembles log4net a lot. These are the only differences, according to the NLog author:

* no object renderers (I believe this is needed in Java, not in .NET)
* no custom layouts (only layout-renderer based)
* no custom loglevels (you get some sort of standardization and library interoperability)
* no cross-thread-serializable logeventinfo - I believe this isn't needed
* no plugins (actually the architecture is very pluggable, but not this way)
* no logging repositories (there's only one, which brings less confusion)
* no need to use any configuration assembly-level attributes (NLog uses auto-configuration)
* no need to remember class names for targets, filters and layout renderers (uses "File" instead of "log4net.Appender.FileAppender")
* very simple and readable configuration schema
* only two configuration languages to memorize: xml configuration language and layout renderer sublanguage ${message:uppercase=true}
* less abstraction at the logger interface (log4net.ILog is an abstract interface while NLog.Logger is a concrete, highly optimized class which improves non-logging speed down to 8 nanoseconds per non-logging call (on my Centrino 1.6 GHz laptop - thanks to the kind Anonymous for making me clarify this))
* support for many common overloads in the logger API (to eliminate memory garbage wherever possible)
* a File target which is multiprocess-safe by default
* mixed-mode API for C/C++ and COM Interop API
* asynchronous targets (write to file, network in a separate thread - available in Subversion, not in the 0.9 release)
* one binary distribution that works for Mono 1.x, .NET 1.0, .NET 1.1 and (probably) .NET 2.0
* support for ASP and ASP.NET layout renderers

It sounds that NLog is a bit simpler than log4net and this might be actually a good thing, since my current project is short and sweet. I will try it and if I get it to work smooth quickly, I will stick to it.

A Surprise Project

2006-03-24T17:32:00.000+02:00

As I was preparing to join an ASP.NET project this week, there came a chance to do another little project. It is about monitoring and sending commands to an embedded device through a serial port. I estimated the work hours and if we reach an agreement with the client, I will start coding next week. The cool thing is that I will get some experience with .NET 2.0, since it introduces a new class System.IO.Ports.SerialPort (which hopefully is going to make the task pretty trivial).

In my preparation for the job I searched what's new or changed in .NET 2.0. I don't want unpleasant surprises and I like to try some new things like generics, anonymous delegates etc. I found a great summary here and you might also check all free excerpts of Patrick Smacchia's book Practical .NET2 and C#2. A great resource on the .NET class SerialPort is this Noah Coad's post. In the meantime I got acquainted with some serial port theory and tried a few useful tools to monitor, sniff or emulate serial port communication. I found a cool tool that creates a virtual COM port and forwards all its communication to TCP port, so I wrote a simple TCP server to log the data received at the virtual port and I will also write a simple TCP client to send data.

Another interesting thing I tried today was an alternative .NET 2.0 enabled IDE. VS.NET 2005 has its problems and one of them is that it is slow. Unfortunately the machine, I am working currently on, can't tolerate much CPU and memory pressure. I searched for a more lightweight IDE and stumbled upon X-develop, which looks superb. It is feature-rich (actually in a few ways it's better than VS.NET, even when powered by ReSharper) and it seems a little less CPU and memory hungry. I can evaluate it for free for 20 days, which is enough for the task, but I might stick to VS.NET 2005.

The estimating part is what bothered me a bit. I had a chance to test my skills in this area a few monts ago and it didn't work out very well. I had a list of another developer's estimates that seemed too conservative to me. I thought that I could implement the features twice or thrice faster, but at the end the other's guy estimates were more closer to reality. But since it was not a greenfield development and the code was not easily maintainable, probably that's why it took so long.

Now I am starting from scratch, I have a good idea what is to be done and all the implementation details are pretty clear. Let's see if I get it right this time. The not so obvious time-consuming activities that I tried not to ignore included: communication, writing testing and logging code, takling unpredicted problems, etc. Some people recommend that you multiply your estimated coding time by three and you are likely to come close to reality. But it depends on the project scope and the people involved. In my case I should multiply probably just by two, since I will do it solo and it looks pretty straightforward.

Preparing for ASP.NET

2006-03-20T13:57:00.000+02:00

Since it is very likely that this week I will start working on an ASP.NET project, I took some training recently. I've had some experience with ASP.NET last year when I was developing a sample bug tracking app for about a month. It was a good warm-up exercise and it gave me a good feel about web development with ASP.NET, but I can't say I grok it. Aside from not grokking ASP.NET, I don't really know enough about JavaScript, CSS and even HTML to be a (super)effective web developer, but I think I am a quick learner so it is just a question of time to catch up.

If you are starting with ASP.NET I highly recommend to look at the webcasts (presentations and labs) by Fritz Onion. I watched three of his four introductory ASP.NET webcasts. He presents his stuff in a logical and easy to understand way, and the Q sessions are also often worthwhile listening. I feel that video content is a great media for effective learning and sometimes I prefer it over books. Also the quick start tutorials are a nice way to learn, but I guess that working on the real thing coutns most.

Influenced by Writings

2006-03-18T11:51:00.000+02:00

I can't resist to share how much I enjoy the writings of Steve Yegge, that I stumbled upon recently. It feels like discovering a gem, when you have not been looking for one. I've already read about eight of his rants and all of them are very thought provoking. While I don't necessarily buy on everything that he is saying, he always has an interesting point to make.

After I discovered Joel Spolsky's website a few years ago, I was so stunned by several of his articles like The Joel Test: 12 Steps to Better Code and The Guerrilla Guide to Interviewing, that in the next few months I managed to read all the articles in his archive. It was definitely an eye-opener for me about many aspects of software development. Then it was Martin Fowler and his articles and bliki. Then there was Eric Sink's writings and after him no online reading stood out to impress me that much. Well, there were quite a few good books that were eye openers in some areas, but nothing mind-blowing for me, they just gave more depth in fields about which I had a good enough idea. And now Steve Yegge offers high quality original content, that I definitely will not be content until I read it all.

Software Books

2006-03-16T11:38:00.000+02:00

Yesterday, I asked my boss to get some books for our library. Hopefully, the company will purchase some of them, but what's interesting for me is how many people are going to read them (me included, heh). I wonder why so few developers actually read books to improve their skills. Well, it is not just about skills. Books can make you see things in an entirely new light. They can illuminate a way out of seemingly difficult problems. They can motivate you and take you out of your routine way of perceiving and thinking about problems. They can open your eyes to new patterns and help dissolve your old patterns. They can stretch your mind.

Well, there are myriad of software books covering areas like: methodologies and management, programming techniques and practices, programming concepts and patterns, languages and frameworks, bits and bytes. So the next step is to identify what kind of books really matter - in the short term and in the long term. After you decide what's your current priority, you just pick the best one and read it, and take notes and apply what you read. Well, the picking a priority and a good book is not always that easy - you can't really estimate what you are going to get, before you get it. And you don't want to skip the note taking and the process of applying the learned, if you want to the concepts to get in your long-term memory. But even if you don't do it, you at least will have a clue where to look when you identify issues that are addressed in the book. But as I said unless you play enough with what you are learning and internalize this knowledge, it will vaporize in a week or two (I can't recall the exact percent from some research studies, but it is about 60%). So play with it, discuss it, blog about it.

I recently read Steve Yegge's article Ten Great Books and the follow-up Ten Challenges. Out of the essential 10 books he listed in the first article, I have read the top three, and I really feel great about them. Well, I can not say that I benefited much from the Design Patterns book (maybe I should check if Head First Design Patterns is more easy reading). So if you are interested on which books for which I aled (those are ones I have not read, only heard good things about), here are the notable six:

Agile Principles, Patterns, and Practices in C# - (to be released in may)
Code Complete, Second Edition
Head First Design Patterns
Agile Software Development
The Art of Project Management
The Visual Display of Quantitative Information

Website Update - Make it del.icio.us friendly

2006-03-14T15:05:00.000+02:00

Since I have been an active del.icio.us user for a few months, I thought it is a nice idea to add to my weblog some stuff, that I tag. Now, there are (1) a tag cloud and (2) recent links tagged 'programming' (which is currently my most used tag).

Of course, you can always subscribe to my del.icio.us feed. Why would you like to do that? Well, actually is not likely you want to. What's new and interesting for me, might be boring and off-topic for you. Probably only my twin from a parallel universe will find this stuff 100% valuable and can't live without it (unfortunately he won't have access to this internet). And you don't want to spend too much time reading crazy programming articles, trying cool tools, or paying attention to whatever I tag (not strictly computers). After all, though this can be fun and sometimes even useful, following links can take you hours and prevent you from doing more important tasks.

I feel a bit confused about the tagging system that del.icio.us and look-alikes use. On one hand, it is simple and useful in many cases, but I still want to have some hierarchical relationships between tags: 'software' includes 'programming' includes 'languages' includes 'ruby' - you get the point. I don't find a way to do this now. And the motif Worse is Better does not appeal to me much. I hope that this issue will be addressed soon.

More Reasons To Learn Ruby

2006-03-09T17:43:00.000+02:00

After thinking about what language should I learn, I decided that it will be Ruby, but I actually did not commit myself immediately to this endeavor. I continued to search for resources and to prepare for the learning. It was not until this week that I started reading the fascinating Poignant Guide To Ruby and I definitely will finish it.

I also gathered more evidence that there are pragmatic reasons to learn Ruby, except as a brain exercise. I stumbled upon some very interesting Stevey's rants and I can't help myself to recommend his articles Tour de Babel, A little anti-anti-hype and Bambi meets Godzilla.

There is also this WATIR web application testing tool that's for Ruby, that seems cool. Today I heard of another very interesting way to use Ruby. A bridge between CLR and Ruby is being developed by John Lam and you can read all about it here. Fascinating stuff!

Collaborating on PowerPoint

2006-03-06T16:26:00.000+02:00

If you need to collaborate on creating and refining a MS PowerPoint presentation, you might be surprised that this Office product lacks most of the great reviewing features you've used to in MS Word. There is no way to see what has been changed, deleted or added. You just can insert comments, which is useful, but rarely sufficient.

I wondered what can be done about this problem. I came up with a simple solution:
(1) export to MS Word ('Save as RTF' or 'Send to MS Word') the original and edited versions and (2) use the Compare function of MS Word, to get a detailed view of the changes.

I thought of automating these steps, but I first consulted with Google for an alternative solution. And there was this great (but commercial) tool to diff PPTs and other types of formats, called Diff Doc. It is really cool and makes it easy for you to get a good understanding exactly what changes were made. Just what I expected from such a tool. So, if you are doing powerpoint reviewing, don't hesitate to try the trial version (it seems that it is not functionality constrained).

Dumb Moments

2006-03-02T15:07:00.000+02:00

I guess that every developer has had moments when he had a problem, that seemed impossible to occur, and spent hours trying to find its cause. And then suddenly he has an epiphany and says to himself "Oh, how can I failed to seen such an obvious thing, am I dumb or what!".

I just had a dumb moment. I was working on a WindowsForms app, and experimented with displaying hierarchical data in a grid. To speed my testing I create a method were I filled a dataset and then bound the grid to it. I'm using TestDriven.NET so in my form I made a temporary method to open the form after loading the data. The form showed up and the grid was empty.

I tried to verify that I actually filled the dataset and that I bound the data correctly. Everything looked great but it didn't work. Then I realized that in the project, we have many times used hierarchical dataset bound to a grid, so I just had to duplicate what worked. Incrementally, I did everything to duplicate the existing working behaviour, and each step tested if it worked. I finally had 100% identical way of filling data and the grid was still empty.

And then I realized what I have done. My method for displaying the form was initializing the members in the current instance, but I was creating and showing another instance of the form. No wonder it was empty! Argh, I suppose that if I did pair programming this wouldn't even become an issue.

A Podcast Cocktail of Apple Pie and Lexicons

2006-03-02T11:00:00.000+02:00

Podcast has been a buzzword for the last couple of years, and if somebody hasn't acquainted himself with its mysterious nature, it is time to catch up. I promise, I will quote only the highest authorities, so you can't be misguided.

There is a legendary podcast on podcasting from the mysterious ninja master. If you are under 12 or by some mysterious circumstances you don't want to watch, I'll seduce you with a teaser. In this podcast the Ninja master revealed (btw, in a very articulate way) that:

Podcasting is a factory for producing apple pie for whales.

For the complete archive of his words of wisdom look here. If you take the ninja way, you will never be the same man again.

And a word from the owner of the Best Page of the Universe

Someone had the revolutionary idea of taking a compressed audio file and putting it online. Yeah, doesn't sound so sexy when I describe it for what it is, does it you morons? It would have been a great idea if streaming audio wasn't already around for over a decade before the word "podcast" entered the lexicon. Man, I can't stand the word "lexicon." Talking about all these shitty words has made me start using shitty words. I'm so pissed, I just slammed the door shut on some kid's nuts.

You are beginning to understand the true and mysterious nature of podcasting. Now, it is time to take the red pill and dive into the podcasting ocean. The pill is big so you might need a GPL fresh lemon juice to help you along the way. I took the juice today. Though I didn't feel that I needed it desperately, it was not a pain either.

Launchers Revisited (Again)

2006-02-28T10:58:00.000+02:00

I blogged about launchers here and here, but recently I found another excellent tool - called Qliner Hotkeys, that deserves mentioning. Pretty good looking, innovative and cool. It can even make your CapsLock key do something useful, heh.

In the meantime I dropped out Collibri because it was trying to be more inteligent than it should and had inconsistent behaviour. I turned back to Launchy, which in new version has added icons support and fixed its combobox peculiarities.

Coding4Fun - Scheduled WAV Player

2006-02-22T17:58:00.000+02:00

I needed an assistance for my morning exercises - a reminder when I have to start/stop an exercise and move to the next one. So when I want to time things perfectly I don't need to look at the watch all the time.

I couldn't find an app that does this, so naturally I decided to write one. It's pretty simple and it does only what I need it to do. Take a look at its (not very polished) GUI, which hopefully is self explanatory [click to view larger image]:

It took me a little longer to build it, than I initially estimated. I guess it is always like this. I am a bit sorry that I didn't try TDD while developing it, because I need to get some experience with this technique. But, nevertheless, I learned some new things along the way - how to play WAV sounds, how to use DataGridTableStyle. I also reminded myself how useful might a log window be (the one on the right).

How do you know when your classes get overweight?

2006-02-21T17:44:00.000+02:00

Unless you refactor your code regularly, your classes will tend to grow bigger in terms of LOC and responsibilities. This is just the inertia of adding a little bit here and there without considering the need to separate concerns and apply the principles of "single responsibility" or "divide and conquer".

These days, I am working on a form with 5000 LOC (well, 2000 are designer generated code, so they don't count) and about 100 methods. These numbers are a good indicator that it might be time to consider doing some reorganizations (here, I am using the mildest language, I am capable of, heh). Another hint your class has gotten way too big, is the time it takes ReSharper to process it - about 10 seconds in my case.

DataBinding - a Blessing or a Curse

2006-02-20T17:18:00.000+02:00

I was doing some WindowsForms coding today and had to deal with the concept of data binding. I am not a big fan of databinding. I am not an expert in it, either. But, I know it can save a few of stupid lines of code and I appreciate its declarative nature. On the other hand it has too many caveats that make me run away from it. If you are doing anything a bit complex, you have to understand in detail how databinding really works, what are BindingContext and CurrencyManager and probably a lot more. I ran into a two part article on CurrencyManager that cleared some of my confusion, but did not won me on the databinding side.

Some months ago I had to track a magic bug with simple databinding of columns to textbox and after wasting half a day in various experiments and searching the net for any clues, I finally had to give up. I just changed the code to skip the databinding altogether and did it in the straight forward way. Today it took me another hour to get clear why some simple things didn't work as expected and I don't think that databinding is worth all those troubles. Some people are convinced that databinding in .NET is just not usable. I think they are right to some extent, though I really would like to know how the design would look like when done right.

Touch typing (week 9 overview)

2006-02-17T20:08:00.000+02:00

This was my last week of intensive Stamina practice and I think I finished it with style, heh. I beat my previous best of 288 CPM when today I passed the 300 CPM barrier scoring twice above it – 316 CPM (5.9% errors) and 311 CPM (4.6% errors). Another very interesting score was 272 CPM (2.0% errors). It was a great example of low error rate, but such low error rates are exception for my typing (on average I type with 7% errors on the exercises).

So let me give the links that log the progress of this learning experience: Starting on Dec 21 2005, week 1, week 2, week 3, week 4, week 5, week 6, week 7, week 8. And a bonus link, heh.

So what the numbers say: Initial leap from 115 CPM to 196 CPM in week 2, 237 CPM in week 3, 254 CPM in week 4, 280 CPM in week 5, 288 CPM in week 7, and finally 316 CPM today. Beware, that these scores do not include the error rate, which is a crucial component. It was reduced from average of 12% to average of 7% (one of my mistakes along the way was probably, that I didn’t concentrate on reducing errors earlier in my training).

I just retook the test that I had taken in the beginning of my training (the old scores are crossed out). The improvements are not that spectacular, but this is due partly to the nature of the scoring and partly due to lack of training in this specific type of test.

	Fishing in Finland	Wonderful Wizard of OZ	Tigers in the Wild
Gross speed (CPM)	196 242	~~220~~ 254	~~218~~ 245
Errors (words)	17 15	17 20	22 11
Net speed (CPM)	~~167~~ 217	192 222	~~182~~ 228
Accuracy (%)	85 89	87 86	85 92

Visual Feedback

2006-02-17T16:02:00.000+02:00

Jeff Atwood has posted about the importance of Colorization. That's funny because I was just starting a rant how bad I feel when I work without ReSharper's highlighting in VS.NET (I had to turn it off temporarily, because of a monster class which took forever to be processed). It is amazing how less efficient I was, when staring at the traditional black and blue letters. Even though I missed the error highlighting on the fly, I realized that the proper colorization of code elements was just as important to me.

LinkBlogs and Social Bookmarks

2006-02-16T15:42:00.000+02:00

I wonder about the value of linkblogs. Basically these are daily/weekly lists of links that a blogger shares, because he finds them interesting or important. The links are usually accompanied with a brief description and commentary. Some linkblogs I read (or at least used to read when I had more time to do so) include:

Usually about half of the links I've already seen. Naturally, some links are irrelevant to me, but there are always ones that I find interesting. I wonder where the noise-to-value ratio is less: in linkblogs or in social bookmarks sites like del.icio.us or digg? Last week I spent some time to look at digg and after investigating more than 50 links in its "programming" category there were just 5 that were interesting enough to be read diligently.

The noise in linkblogs is usually slightly lower. Linkblogs also have the advantage that once you get to know what the blogger is interested in, you can decide whether to continue reading them.

Having a rich enough subscriptions list, I was reluctant to try any social bookmarking sites, but they surely have some advantages. You can keep your favourite links organized and later find them very easily. And when you have a decent browser/aggregator integration it is almost effortless. So I am becoming a more and more active del.icio.us user.

On "Mark Miller works the DXCore" dnrTV show

2006-02-15T10:50:00.000+02:00

I would highly recommend watching Mark Miller works the DXCore on dnrtv.com. This is a great show, demonstrating the things you can do with the free DxCore VS.NET add-in. In less than an hour Mark built a pretty sniffy VS.NET extension, while simultaneously demonstrating the productivity features of CodeRush and Refactor!. These two products look pretty cool, especially for demos (there are animated arrows flying around telling you what clever feature you are using). Well, I find ReSharper to be a bit more practical tool, but that's probably just because I've got used to using it.

So if you have a clever idea for a VS.NET extension you will save a lot of efforts if you take a look at DxCore and some of the available addins built on it.

It will be Ruby

2006-02-14T13:25:00.000+02:00

After my recent ruminations about LISP and Ruby, I listened to an interesting interview with David Thomas and I ran into a fascinating comparison of C++ vs Java vs Python vs Ruby. I am becoming more and more convinced that if I decide to invest time in learning a new computer language, it has got to be Ruby. I should get a good (preferably short) book on the topic (maybe this one), but I wonder where to practice Ruby programming. Let's hope that there will be some tasks at work, suited it. I may also start a pet project with Ruby if I got hooked very much, but that's not much likely.

Touch typing (week 8 overview)

2006-02-11T22:42:00.000+02:00

Another week of eased touch typing practice passed and I missed a few days of practise. But today I had a few seesions and did some progress on lowering error rate. For example I did 279 CPM with 4.7% errors and I just made 253 CPM with 2.5% errors. I liked the 2.5% errors session better and I feel I can further improve it. I wonder why is it so hard for me to type completely error-free?

But, you know, 8 weeks of touch typing seem enough time investiment to me, and I plan the next week to be my last one with this practice (to sum up 2 completet months). I may refresh my skills once or twice a week with 15 mnutes practise, but this skill acquisition process will not be that active after next Friday. I also plan to retake the exam I took in the beginning of this endeavour to see how much I improved (though I don't think it's scoring is very objective).

My Firefox Configuration

2006-02-10T17:49:00.000+02:00

Firefox has been my default browser for a few months, and I have been experimenting with some extensions for power users. Today I find the ultimate extension that can help me cope with the other extensions I have installed, heh. Take a look at what HTML file it generated automatically. Nice!

Generated: Fri Feb 10 2006 17:52:00 GMT+0200 (FLE Standard Time)

User Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.1) Gecko/20060111 Firefox/1.5.0.1

Build ID: 2006011112

Enabled Extensions: [16]

Adblock 0.5.3.042

BugMeNot 1.3

CustomizeGoogle 0.41

del.icio.us 1.0.2

Download Embedded 0.2

DownThemAll! 0.9.8.7

Gmail Manager 0.4.3.2

IE Tab 1.0.7

Mouse Gestures 1.0.4

MR Tech Local Install 4.1.1

Paste and Go 0.4.3

PDF Download 0.6

Reveal 1.0.5

SessionSaver .2 0.2.1.031

Tab Mix Plus 0.3.0.2

Xinha Here! 0.7

Disabled Extensions: [2]

Mozilla SpellCheck Libraries 1.0.1.0

SpellBound 0.7.3

Total Extensions: 18

Installed Themes: [1]

Firefox (default)

Installed Plugins: (6)

Microsoft® DRM

Mozilla Default Plug-in

PCMan's IE Tab Plug-in for Mozilla/Firefox

QuickTime Plug-in 7.0.3

Shockwave Flash

Windows Media Player Plug-in Dynamic Link Library

ReSharper EAP

2006-02-10T16:03:00.000+02:00

I have been using build 215 and 216 of Resharper 2.0 EAP with VS.NET 2003 (and a little with VS.NET 2005) for about two weeks and I have been very happy with all the new features that it offers. It is still quite buggy, but the new features are so compelling that I have decided to live with it. There are some little problems with graphics and sometimes the internal parser's state gets messed up, but I have not experienced no extremely bad consequence. Today was the first time my IDE crashed completely, but I just saw that there is a new bugfix build 217, that might have addressed this problem.

It is interesting how tools influence the way you work. Now I am doing somewhat strange refactorings such as replacing unnecessary static readonly with const, in order to take advantage of Resharper's ability to show me a tooltip with the value of the constant. That is quite useful when you have texts as const variables. I don't have to navigate to them to see their value and that's how I am saving two keystrokes :)

Language considerations Ruby and LISP

2006-02-09T14:05:00.000+02:00

I often wonder if all the talk about programming languages is worth. Really, there are lot of articles and dicussions on this issue - just visit the popular programming related topics at del.icio.us. Each day you will see plenty of links to programming languages, and Ruby and LISP are currently leading the field.

I was reading a lot of Paul Graham articles lately and I was a bit perplexed how devoted LISP fanatic he is. And he is definitely not the only one. I just finished an interesting (and somewhat funny) article Tin Foil Hats and Rubber Ducks which basically said that LISP is the answer (read it to understand what the question was). I also stumbled upon an excellent post by Sriram Krishnan LISP Is Sin. There I saw claims like the one that Peter Norvig's Paradigms of Artificial Intelligence Programming - Case Studies in Common Lisp is “the best book on programming ever”. Sounds interesting?

So if you read those articles, you might take LISP really seriously. There are some newly emerging anguages in the Lisp family like Erlisp which will add threading support and distributed features. My personal experience with functional programming is from the university where I took the regular Scheme course. I can’t say I was that impressed, though having the possibility to the some more high-level programming was interesting. I wonder how LISP would feel on a real project, will it scale well and how easy will be to test and maintain the codebase.

The Ruby language is really getting more and more popular and it looks like it may become mainstream sooner or later, being promoted by the pragmatic programmers and many other influential figures in the industry. I have note really tried to do anything in Ruby, except playing for 15 minutes with it online. Can’t say much about it! You might check the post Why Ruby is an acceptable LISP - it makes some really good points.

These language discussions make me think about whether being focused entirely on C# and .NET in the last dew years was a good decision. I actually think it was, though it might not ahve been the best one. In retrospect, it took me about two years to become a decent C# developer (I thought I was good a lot earlier, but this was selfdillusionment, heh). There are just a lot of best practices to learn, not only in coding but also in the broader topic of object-oriented design. If I have let myself be distracted by languages like Ruby and LISP, I would not have been that proficient and productive with C# now.

Well, many authorities say that in the long run it is wise to learn a new language each year, but I don’t really think that’s true, unless you have it as a hobby. You might be preparing for solving problems that never really show up. Maybe the agile approach to attack the current problems at hand is more effective, but if you are doing it only for fun, it is a different story.

I find a parallel between reading weblogs and learning languages. You might learn something new (I learned a lot from weblogs) but sooner or later you get stopped by the law of diminishing returns. In the recent months there were progresively less things that I found valuable in the weblogs I read, so I had to unsubscribe from some and subscribe to others. Maybe it is time for me to drop some of my .NET blogs and to focus on something else for a while? If I knew that I would use in the coming months .NET 2.0, I would probably not have thought about it. But it doesn’t seem likely, so I might give Ruby a shot. Why Ruby or why not?

Launchers - revisited

2006-02-07T18:24:00.000+02:00

Since my last post about launchers, I had the chance to try a few others, just for the fun of it.

I liked Collibri, which is pretty much like Launchy, but its GUI is far superior (well, the price you pay is a few more megabytes of your RAM). It can even do things like Google search and a few other goodies, but I don't find those that useful. I just noticed, that Launchy has gotten a recent update and has some new features, but for right now, I'll use Colibri (it is better in impressing my co-workers, too).

Another cool app is JetToolBar succeeds to improve the experience with starting things in Windows by creating a toolbar with categories where you put your shortcuts. It does its job in a pretty nice way. You can move the toolbar in any position on the screen, it can autohide and come again with a hotkey.

I accidently tried a commercial app called JetStart, which combines nearly all the features I expect from such type of software. It has very well thought GUI and integrates seamlessly with Windows (some might say that it is even too intelligent, heh). In fact, it has a free version, which only major limitation is that you can't add your own categories.

Touch typing (week 7 overview)

2006-02-04T18:17:00.000+02:00

This week I eased my touch typing training and had two days without Stamina practice. The next week I will concentrate solely on errorless typing. Till now, I have never reached less than 3.5% errors and I wonder how it feels to do with 1% errors or less. I will try to do it, even if that means I have to type with 60 CPM for a while. I have a feeling that error-free typing can create some kind of a flow that may increase speed substantially.

Actually, this week I beat my personal best, scoring 288 CPM today (7.1% error rate). I also did some other good session like 275 with 6.3% error rate and similar. I pretty consistently type with speeds between 270 and 285 CPM, though there are sessions I settle for 240 CPM.

I try to analyze what my greatest difficulties in typing are. When I see an uppercase letter coming, I lose a lot of time, coordinating my movements. I know I should hit the key with one hand while the other hands reaches for the Shift key, but often I do a mirrored move, which gives me, for example, T instead of I, heh. I also have some problems with the punctuation and with the symbols like $#&*. I better turn back to “lesson” mode to memorize these character positions better.

This week my typing companion piece of writing was Richard Hamming’s talk You and Your Research, that Paul Graham highly recommended in his essay Good And Bad Procrastination. It is a very insightful talk and if one wants to become great in the area he works in (even if it is not science), it is a recommended reading. Well, it is rather lengthy (I had to hit about 30 times PgDn to get to its end in my browser) but still I think it’s worth.

Setting up my work computer

2006-01-29T16:51:00.000+02:00

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)

2006-01-29T13:41:00.000+02:00

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

2006-01-28T16:13:00.000+02:00

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

2006-01-26T15:35:00.000+02:00

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

2006-01-25T19:38:00.000+02:00

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

2006-01-25T16:37:00.000+02:00

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

2006-01-23T16:58:00.000+02:00

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

2006-01-23T13:14:00.000+02:00

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)

2006-01-21T15:17:00.000+02:00

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

2006-01-20T18:27:00.000+02:00

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

2006-01-17T16:44:00.000+02:00

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

2006-01-17T14:11:00.000+02:00

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)

2006-01-14T17:12:00.000+02:00

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

2006-01-13T18:40:00.000+02:00

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.