mQENBEvohxQBCADnBH+Dc3OMgTfH7zbZt4ycDujXrtFwyQvMaOoceRs4Zdv31cl7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=tt0w
—–END PGP PUBLIC KEY BLOCK—–

One cool thing that I recently installed there is a feedback system from www.uservoice.com.  It’s a simple piece of JavaScript to add to your pages, which lets users submit suggestions, vote on them (so you can prioritize them, and even have a forum to discuss them.

Think of this like cooking.  Let’s say that our framework provides potatoes to chefs.  Without the framework, each chef  needs to get their potatotoes, peel them, slice them up into the shape needed for the recipe, and cook them.  If we build something that provides us with peeled potatoes, that saves time for 95% of our recipes.  However, if we build something only provides peeled and diced potatoes, that’s not going to help the chef who needs sliced potatoes.  If our “cooking framework” only provided us with peeled, diced, roasted potatoes, it would be a great time-saver for 5% of the recipes, but useless for the remaining 95% of them.  So, I’m starting out the framework to do the simplest, most common tasks.

In the applications at work, one of the most common tasks is to get a list of jobs from the database.  I expect that most programs have their own code to access the database and get this list of jobs.  With all those different versions, we end up with several problems.

• - The code for each versions may not be optimized (the query being used, handling of disposable objects, caching, etc.)
• - If we ever need to change the database (or it’s structure), we need modify each program.
• - If we want to improve performance with caching, we end up with one cache per program (not as efficient as a common cache).
• - Each programmer had to spend time writing, testing, and debugging their version of the function.

So, this will be the first thing I’ll add to the framework.

I created two projects: ABCD.BusinessObjects and ABCD.Persistence (”ABCD” will be the fake acronym I use for our real division).

The ABCD.BusinessObjects project will be used in almost every project.  This contains classes like the Job object.  I’m building these classes using the Data Mapper design pattern.  I don’t want to use the Active Record design pattern, where the record contains methods to create, read, update, and delete that object from the database.  All the database access code is going into the ABCD.Persistence project.  My feeling is that the Active Record pattern produces objects that don’t pass the “Single Responsibility” aspect of the SOLID principles.  These classes are currently fairly simple, containing mostly get/sets for the properies.

All the business objects inherit from a BaseBusinessObject class.  The only thing in that class is a getter for a virtual boolean property named “IsValid”.  It currently returns “true” in the base class.  By overriding this method in the derived classes, we can have all the validation rules stored along with the class.  Even though the base class doesn’t do anything yet, I put it in place to provide me with a point of flexibility in the code.  If we need to add in something that applies to all classes later on, we already have a place to put it.  If we don’t, even though this class violates the YAGNI principle, it isn’t a burden on us for performance or developer understanding.

The only thing in this project (other than more business objects) is a class to hold enums used by the business objects.  It’s a public static class named ABCDEnums.  I’m a fan of using enums for the datatypes of properties.  I’ve run into too many situations where a boolean property suddenly needs to store a third value.  I believe that FxCop (Microsoft’s code quality tool) even mentions that you should have an “Unknown” or other default value available with each enum.  The reason I’ve added this enums class is because it makes the enums very visible through Intellisense.  If I can’t remember the exact enum name, all I have to do is type “ABCDEnums.” and they will all appear.  That’s also the reason why I’m naming all the namespaces with ABCD.whatever.  When I’m adding in my “using” statements at the top of the class, I quickly get to the point where Intellisense starts showing the available namespaces.  That’s much easier than trying to remember the exact spelling and upper-casing of some long namespace like “BusinessObjectsForEAISystem”.  Although, a tool like ReSharper would be even better (IIRC how it worked during the 30-day trial of it).

My next post will be on the ABCD.Persistence project.  I’ve been going back and forth on a couple of ways of building it, and I expect I’ll have that finalized soon.

What does all this have to do with programming?  While thinking about how to develop a good framework for the suite of apps I work with, I’ve been looking at what I’ve seen that works and what doesn’t work.  One thing that I see a lot of is procedural code written in object-oriented languages.  We’ve all seen (and probably created) classes with a method that is hundreds, if not thousands, of lines long.  You got you procedure in my object!  But I think the opposite problem can also occur.  When working towards an “ideal” application, you can try forcing procedural processes into objects, handling them with massive event raising or forcing them into place with an implementation of the Chain of Responsibility pattern.  You got your object in my procedure!

One of my thoughts when creating this framework is to have objects (Customers, Jobs, etc.) represented by objects, and have processes handled in procedural methods.  I’ll still be following the SOLID principles, especially Single Responsibility and Dependency Inversion.  However, I won’t be forcing things to use styles that don’t seem to be appropriate.  My next post will go into some detail of how (and why) I’ve set up the projects for the framework.

BTW, as I started writing this, a friend of mine sent me an e-mail with a link to a funny history of computer languages, complete with a reference to the chocolate/peanut butter commercial.  Check out this Brief, Incomplete, and Mostly Wrong History of Programming Languages for a laugh.

The job I’m at now is full-time, heads-down development.  However, it’s Windows Forms applications instead of the web services, Windows services, and back-end business processing that I’ve been doing for most of the last several years.  I finally get to spend my days writing programs that users can actually see!  After years of staring at XML all day, it’s cool to work on something that shows graphs of data … in different colors, even.  Without going into more detail than my boss probably wants me to, the programming team I’m working on produces a suite of dozens of individual applications that all go against the same database.  “My” application parses files in numerous formats, displaying the data in graphs and reports.  It also needs to send the parsed data to the database and be able to output it in a couple of other formats.

My current focus (and what I’ll be posting about) is building a high-performance framework that can be used by all the applications in our suite.  I’m not building the framework from an ivory tower.  Instead, I’m writing a stripped-down version of the application I work on, and building it in a way that will make it highly re-usable and improve the performance.  At work, there’s a definite C++ bias for anything that needs to be high-performance, but I think I can do just as well in plain-old C# (plus avoid the overhead of COM interop or P/Invoke).  So, whenever I build part of the framework, I write a mini-load test app to see how well it works.  I’ll eventually start doing some more serious profiling of the throughput, CPU load, and memory usage.

Another thing on my research list is F#.  In order to get a further performance boost, I’ll also be looking at using F# to create code to take advantage of multi-core processors.  I haven’t even written a Hello World program in F# yet, but what I’ve been reading about it has impacted how I’m writing code.  I’m focusing more on separating my “state” from my “process”.  I’ve noticed that I’m starting to write more static methods, which isn’t helping with testability.

While working with the OnRowCommand event on a GridView object in ASP.Net, the code in my code-behind page was not doing what it should have for the asp:ButtonField that I had in the grid.  So, I set a breakpoint and watched what was happening.  When the code got to the line “if ( e.CommandName == “RaiseStoryInPriority” )”, it never executed the code within the “if” statement, even though hovering over “e.CommandName” showed that the value was equal. After trying several different things (and beating my head against the wall for far too long) I tried running the code through IIS, instead of the Cassini web server that runs your code when you press F5 in Visual Studio.Net. The code worked perfectly in IIS.

I also ran into a different problem with Cassini a while back. I was using a cache object and tried to clear out a value by assigning “null” to it. That worked in Cassini, but not in IIS. In IIS, I had to use the Remove() method.

So, if you see something that looks like it should be working, but isn’t, it might be worthwhile to run it your application through IIS and see if you still have the problem. That might save you from an hour of frustration.

The problem I had was trying use a mock object for my data access layer, and calling a void method on the class.  There are thousands of examples of how to mock a method call that returns a value, but it took a while to find out how to handle a method call that doesn’t return anything.  In my test below, if the method returned something, I’d use code like this:

For a void method (or ‘Sub’, instead of ‘Function’, for the VB.Net developers), you need to set up a delegate instead. See the line that calls “ExecuteNonQuery” for an example.

That may not sound like the kind of things that comes in handy very often; however, it’s making my life much easier for the latest project I’m working on.  I’m working on an ASP.Net website, but I also plan on creating a Visual Studio plug-in, so developers can access the website features without needing to leave their editor and open a new browser.  I may also end up writing a system tray tool that works the same way.  I haven’t decided if the plug-in will communicate with my application by a web service, remoting, or WCF.  But whatever method it uses, I’ll just end up writing a small bit of wrapper code in it to communicate with my business logic through the user story API.

Normally, my solution file will start out with four projects in it.  They are:

- MyLibrary (containing things like my data access layer)
- Domain (the application’s business logic)
- Application (the UI project)
- TestDomain (unit tests for the Domain project)

The MyLibrary and Domain projects each contain an Interfaces folder, and the files within them are in the MyLibrary.Interfaces and Domain.Interfaces namespaces.  The Application project has references to both the MyLibrary and Domain projects.  However, since I’m going to have additional projects that will be passing objects of the interface types into a web service (for this example), They will either need to include the complete MyLibrary and Domain assemblies, or I’ll need to move the interfaces into their own assemblies.  In order to keep the installations for the new projects small, I’ll move the interfaces into their own projects.  So, the solution will now look something like this:

- MyLibrary (containing things like my data access layer)
- MyLibrary.Interfaces (the public interfaces used within MyLibrary)
- Domain (the application’s business logic)
- Domain.Interfaces (the public interfaces used within Domain)
- Application (the UI project)
- Notifier (system tray notifier project)
- Plugin (Visual studio plugin project)
- WebService (used by the Notifier and Plugin projects to communicate with the Domain layer)
- TestDomain (unit tests for the Domain project)

The Application and TestDomain projects (along with the new Notifier and WebService projects) will now need references to the new *.Interfaces projects.  However, the Notifier and Plugin will only need to have the small *.Interfaces assemblies included for the installation.

The first thing I did to my development virtual machine was to set the desktop background to a different color.  Since I’ll be switching between multiple VMs, I figured I’d add a visual indicator as to what machine I’m currently on.  Obviously, the background won’t be visible when I have my programs open.  If I still need something to remind me what machine I’m on, I’ll use one of those utilities that keeps the machine name and details floating above all applications.

For web browsing, I downloaded an installed the following:
Firefox
Opera
AdBlock
Avast! anti-virus (I had been using AVG, but it’s been having some problems lately.  See here and here for more
details)
AdAware

For .Net development, I installed the following:
IIS (Map a virtual CD drive to the operating system ISO, to get the required files)
SQL Server 2005
Visual Studio 2008
Silverlight

Then, the development libraries and tools that I use on a regular basis:
RhinoMocks
NUnit
TestDriven.Net
ReSharper 4.0 is next on my list

For source control, I went with Visual SourceSafe.  I prefer to use Subversion when developing with others; however, VSS suited all the extremely basic requirements I need for solo development.  Plus, it integrates better with Visual Studio than Subversion does.  When I tried VisualSVN and AnkhSVN, there were still a few things they had trouble with (moving and renaming files, IIRC).

For my continuous integration build server, I went with TeamCity, since it makes builds so much easier to create and manage than CruiseControl.  Ideally, I’d set this up on another VM, but I’m keeping things simple, until I find a need to make them more complex.  Something I’ve seen with their system tray notification tool is that the web server service hasn’t started before the system tray notification tool tries to connect to it.  I get a pop-up that the build website is not available yet.  I just give it a minute for the website to start up, then tell it to retry connecting.  I sent off an enhancement suggestion to the TeamCity developers that it would be nice to have a configurable wait setting before the notifier tries to connect to the web page.
TeamCity

Although it’s not on my development VM, I want to mention that I also installed SpamBayes on my ‘office’ VM.  This is a nice filtering tool that helps keep spam out of my inbox.
SpamBayes

My first thought was to have one image for Visual Studio 2005, another for Visual studio 2008, another for my development SQL server, another for my build server, etc.  But I started to realize that I was going to need to be running several VMs simultaneously, just to work on one typical application.  Even with the CPU and RAM that I have, that might start straining my computer.  I also might end up needing to manage multiple versions of each image (e.g., a development SQL Server with no service pack installed, another with SP1 installed, another with SP2 installed).  That was going to get messier than I wanted.

So, I decided to create an image to hold my full development environment for each project.  That gives me the ability to move a complete development environment to offline storage, once I’m done with the project.  If the client comes back a year later and wants me to make some enhancements, I can bring the complete environment back to where it was when I last worked on it.

To do this, I created an image with my base operating system installed.  After running Windows Update until everything was updated, I saved that image as my base OS image.  Then, I cloned that to a base development image.  I installed all the software that I would need for a full development environment (editor, database, source control, etc.) on that image.  After running Windows Update on that image, I cloned that to another image that I would actually use for development.  That way, if I ever need to build up another VM, I can clone from the base and have a clean environment.  When building base images, keep in mind that things will be easier if you configure all your applications the way you want, then build your clones off of that image.  Download your favorite browser and set your home page to your normal home page.  Go into your editor and set your tab stops where you want.  You won’t want to do that each time you make a new VM.

Figure out the size RAM and hard disk you want for your virtual machines.  If they are all fairly close, use the maximum size as your standard VM configuration.  If they are significantly different, you may want to create a few different base images.  If you are using Windows as your operating system, significant changes in machine configuration may cause Windows to think it is installed on another computer, and expect another license key.  I went with 2 gigs of RAM and a 100 gig hard disk.  Even though I set up the hard disk as 100 gigs, they image sizes are currently only taking up from five to seventeen gigs of actual space.

When installing software from an ISO, set up the ISO image as a CD-ROM drive.  If you have trouble running the install from the virtual CD (as I did for a few programs), copy the files over to the VM’s ‘local drive’ and run the setup application from there.

A couple of things I’m not fully happy about, but haven’t figured out how I want to handle them yet, are having my source control and continuous integration on each development VM.  Ideally, I’d like to have all the source control in one place, so I can share code between applications easier.  I can also see that there may potentially be problems with running my CI build on my development VM.  If it starts to cause problems, I’ll post what is happening and how I get around it.

I also created a couple of other VMs, one for all my office functions (e-mail, word processor, spreadsheet, etc.), and one for web browsing.  Doing my browsing on one VM limits the amount of damaged that could be caused by spyware or the latest browser exploit.  If something starts to get strange, just make sure my bookmarks are stored somewhere and rebuild my image.