Ivan Mitev In The Software Trenches

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.