Just added a new page to the site that contains my reading list.  Check it out to see books I've read in the past as well as my current queue of books.

For those of you that were having issues downloading files from my "projects" page, I have upgraded the module and the downloads should be working correctly again.

• Head First Object-Oriented Analysis & Design (reading this as a refresher, currently about 60% through it)
  

• Agile Principles, Patterns, and Practices in C#
• Head First Design Patterns
• ASP.NET 2.0 Unleashed (I already know ASP.NET 2.0 pretty well, but this book is the bible for this technology, so I'm planning on reading it cover to cover just as a refresher)
• Expert C# 2005 Business Objects
• Domain Driven Design

• Learning a new programming language
• Needed a program/application to behave in a very specific way
• The joy of programming just for the fun of it (yes it can be fun!)

I was quite overwhelmed recently when I started researching  OR/M tools for the latest ASP.NET 2.0 project at work.  There are so many to choose from, all with their own unique take on what it means to be a good object-relational mapping tool.  I only wanted to spend a day or two researching/evaluating OR/M tools, and I narrowed it down to SubSonic and EntitySpaces for my final showdown.

SubSonic

I first heard about SubSonic about 6 months ago from one of the many ASP.NET blogs I subscribe to.  The goal of the project is to bring some of the cool RAD tools from the Ruby-on-Rails world into ASP.NET.  One of the nicest features of SubSonic is that it mostly “just works” without too much effort.  There’s no crazy-complicated XML mapping files (I’m looking at you NHibernate…) or mountains and mountains of auto-generated code to dig through (N-Tiers).  SubSonic utilizes a cool feature of the VS2005 and ASP.NET environment called “Build Providers”. All you have to do is make a few adjustments to your web.config file, add a special file to your App_code directory and you’re done!  Whenever you compile/build your VS solution, SubSonic reads your database schema and dynamically generates Data Access classes.

EntitySpaces

I only recently became familiar with EntitySpaces.  A former co-worker of mine really likes the d00dads architecture, the precursor to EntitySpaces.  EntitySpaces takes the code-generation approach, utilizing the popular free code-generation tool MyGeneration.  EntitySpaces is essentially a few .NET dll’s and some MyGeneration code templates.  You load up MyGeneration, open the Entityspaces templates, point them at your database tables, and MyGeneration will spit out a bunch of Data Access and Biz Logic classes in either C# or VB.NET.  My favorite features of EntitySpaces are it Scaffolding support (to auto-generate administration screens for all of your database tables) and its great support for hierarchical data models.

Shot of a scaffold page (notice the drop-down auto-generated for the FK column)

SubSonic

Good Stuff

·         Free and Open Source!

·         Easy to get started / mild learning curve

·         Dynamic Queries

·         Strongly-typed wrapper classes for all your stored procedures

·         Active forums, frequent releases

Chinks in the armor

·         Scaffolding support is buggy

·         Doesn’t handle GUID keys very well

·         Weak support for navigating PK/FK relationships

·         Geared towards ASP.NET only (WinForms is possible)

EntitySpaces

Good Stuff

·         Auto-generated scaffolding is very powerful / time-saving

·         Dynamic Queries

·         Very good support for navigating PK/FK collections in code

·         Able to regenerate Data Access code without affecting your custom business logic

·         Serialization of objects for web services, etc.

·         Active forums / support

Frown Face

·         Not free or open source ($80 for Express edition)

·         No strongly-typed access to stored procedures (it is scheduled for next release though)

Final Thoughts

In the end I chose to drop the $80 for EntitySpaces because of its superior Scaffolding and PK/FK Hierarchical support, both of which have been big time-savers so far, allowing me to focus more on the “real guts” of my application instead of Data Access code.  The addition of stored procedure wrappers in the next version will make it even more attractive in my opinion.   However, I’m definitely going to keep an eye on the SubSonic project, since they are adding features all the time.  The biggest things preventing me from using SubSonic right now are the relatively buggy scaffolding support for GUID data types, as well as the weaker support for navigating hierarchical PK/FK collections in code.

• Code is duplicated
• A routine is too long
• A loop is too long or too deeply nested
• A class has poor cohesion
• A class interface does not provide a consistent level of abstraction
• A parameter list has too many parameters
• Changes within a class tend to be compartmentalized
• Changes require parallel modifications to multiple classes
• Inheritance hierarchies have to be modified in parallel
• Related data items that are used together are not organized into classes
• A routine uses more features of another class than of its own class
• A primitive data type is overloaded
• A class doesn''t do very much
• A chain of routines passes tramp data
• A middle man object isn''t doing anything
• One class is overly intimate with another
• A routine has a poor name
• Data members are public
• A subclass uses only a small percentage of its parents'' routines
• Comments are used to explain difficult code
• Global variables are used
• A routine uses setup code before a routine call or takedown code after a routine call
• A program contains code that seems like it might be needed someday

• Declare and define each variable close to where it''s first used
• This applies especially to code setup needed right before a loop
• Localize References to Variables
• keep subsequent variable references close together (the number of lines between references is called span)
• minimize the average span
• Keep "live" time as short as possible
• "live" time is the number of lines between a variables first reference and its last reference
• A variable could have short span, but a long live time
• Goal is to minimize both span and live time
• Don''t assign a value to a variable until just before the value is used
• Always start with the most restrictive visibility, and expand only as necessary
• Favor the smallest possible scope for a variable: local to a loop, local to a routine, private to a class, protected to a class, package to a class

• If multiple classes share common data but not behavior, create a common object that those classes can contain
• If multiple classes share common behavior but not data, derive them from a common base class that defines the common routines
• If multiple classes share common data and behavior, inherit from a common base class that defines the common data and routines
• Inherit when you want the base class to control your interface; contain when you want to control your interface
  

http://www.martinfowler.com/eaaDev/uiArchs.html

The other I had the challenge of figuring out how to add a toolbar button to a MS Excel file that would send the current file to an ASP.NET web service.  The web service could then take some action on the file, such as send it as an email attachment, or log it to a database.

You''ll need the following tools/downloads (in addition to MS Excel and Visual Studio 2003/2005)

Microsoft Office 2003 Web Services Toolkit

1. Create the ASP.NET Web Service to receive the file. I used VS 2005 to create my webservice, but VS 2003 should work fine also.  The key is to have the web method receive a byte[] array as a parameter, since that is what we will be passing from our client-side VBA code.
   

           [WebMethod]
           public void ReceiveExcelFileBytes(byte[] data)
           {
               Console.Write(data);
               Stream output = new FileStream(
                @"C:\WINDOWS\TEMP\data.xls",FileMode.Create);
               BinaryWriter outputWriter = new BinaryWriter(output);
               outputWriter.Write(data);
               outputWriter.Close();
               output.Close();
           }

2. The next step is to write our VBA code inside MS Excel. Create a new Excel file and open it. Open the Visual Basic Editor by pressing Alt-F11. Add a new "Module" and type in the code below:

   Dim sMenu As String
   
   Sub AddCustomButton()
   
       Dim oCB As CommandBar
       Dim oCtl As CommandBarControl
       Dim newMenu As Object ''CommandBarControl
       Dim ctrlButton As Object ''CommandBarControl
   
       sMenu = "Send to Webservice"
   
       On Error Resume Next
       Application.CommandBars("Formatting").Controls(sMenu).Delete
       On Error GoTo 0
   
       Set oCB = Application.CommandBars("Formatting")
       Set oCtl = oCB.Controls.Add(
             Type:=msoControlButton, temporary:=True)
   
       With oCtl
           .BeginGroup = True
           .Caption = sMenu
           .FaceId = 197
           .Style = msoButtonIconAndCaption
           .OnAction = "SaveToWebservice"
       End With
   
   End Sub
   

3. Next we need to hook-up our function to the Workbook_Open event. Double-click on "ThisWorkbook" in the VBA Editor and type in the following for the Workbook_Open event handler:

   Private Sub Workbook_Open()
       AddCustomButton
   End Sub
   

4. Make sure have installed the Office 2003 Web Service Toolkit, we''ll be using it to generate a VBA proxy for our ASP.NET webservice. Inside the VBA editor, go to "Tools -> Web Service References" menu and add a reference to the URL of your ASP.NET webservice that was created in step # 1 above. This will generate some VBA code that we can use to call our ASP.NET webservice from VBA.
   
   
5. Now we need to connect our custom toolbar button to some code that actually sends the file across the wire. Jump back to the VBA module (where we have our AddCustomButton() method, and add the following code:

   Sub SaveToWebservice()
   
   On Error GoTo Error_Handler
   
       Dim backupFile As String
       Dim fhandle As Long
       Dim webservice As New clsws_ExcelWebService
   
       backupFile = "C:\WINDOWS\TEMP\file_backup.xls"
   
       '' Save a backup copy to retain our VBA code
       ActiveWorkbook.SaveCopyAs backupFile
   
       Dim TypeBinary
       Dim oStream As ADODB.Stream
    
       '' Create the object
       Set oStream = CreateObject("ADODB.Stream")
    
       '' Open our file
       oStream.Open
       oStream.Type = adTypeBinary
       oStream.LoadFromFile backupFile
   
       '' Retreive binary data from the file
       Dim dataLong As Long
       Dim dataBytes As Variant
       Dim dataString As String
   
       dataBytes = oStream.Read
   
       '' call the webservice
       webservice.wsm_ReceiveExcelFileBytes (dataBytes)
   
       oStream.Close
   
       MsgBox ("Successfully sent")
   
       Exit Sub
   
   Error_Handler:
       MsgBox Err.Description &
             " (" & Err.Number & ")",
              vbOKOnly + vbCritical
       Exit Sub
   
   End Sub
   

I found a really good article on CodeProject this weekend on Smart Client development. It goes into a lot of detail on how to implement a Smart Client type application, but it also has some good stuff relating to Design Patterns, and how to implement an “Automation” module similar to MS Word. I haven’t finished the whole article yet, but it looks really informative. Plus you can download all the source code for his sample app :)

http://www.codeproject.com/smartclient/SmartClientSOA.asp

I was looking for a way to attach an event to ALL the input fields on a web page and found this little ditty that lets you attach event handlers to all instances of an element with one call :)

When the window loads, this code will select all the "input" elements on the page and attach my custom function/event handler "myBlur" to each of them.  Which means that anytime ANY of the input fields loses focus, the myBlur function will be called

The COALESCE() function in SQL Server 2005 is cool.  Say you have a database schema as follows (primary keys highlighted in bold):

Widget
widgetId
widgetName

Category
categoryId
categoryName

WidgetCategories
widgetId
categoryId

According to the schema, one Widget could be in zero or more categories. Of course we can write queries to return rows of widgets, and we can write queries to return WidgetCategories for a specific Widget. But what if we wanted to select 1 specific widget by widgetId, and in that row have a column called "categories" that held a comma-separated list of categories that the widget is in?  This might be useful for some kind of summary page where you would want to see all the categories a widget is in, in ONE QUERY.

Enter the COALESCE() function!  Check out the SQL Function below and the SELECT query after it:

The SELECT query:

These two things will accomplish exactly what we are looking for and return:

widgetName                    categories
widgetA                           sprockets, rockets
widgetB                            gizmos, gadgets

Very cool!  I believe the COALESCE function is present in SQL Server 2000 also.

Something caught my attention on the show "Excavators" on the Discovery Channel tonight.  I don''t watch this show regularly, but sometimes I just leave the Discovery Channel on in the background at home and then pay attention when something interesting comes on.

Anyway, the show is about these HUGE excavating machines that are used in massive open-air mining operations to shovel earth into really big trucks that haul it away and process it.  I don''t know all the exact specs of the machine because I just caught the last third of the show, but if you stood next to one of its caterpillar tracks your head would only be about halfway to the top of the track!

In addition to all of the mechanical complexities of the shovel, it also had an extensive amount of electrical sensors and circuitry (I think they said something like 1 million feet of electrical wire!) all controlled by a central computer.  The operator of the rig has a monitor with a custom GUI on it that is used to control the digging operations and the movement of the rig in general.

Now, the show was mainly about the assembly of this thing at the dig site (since they''re too big to transport in one piece) and how they had these teams of mechanical engineers and electricians assembling this thing on-site over a period of about 8 months.  The show really focused on the problems that arose in the last 7 days before the "launch date" (the date in which it was scheduled to start digging).  Once the electricians had run all the wires and connected everything, it was time to do some test runs with the digger and the caterpillars, and this is where it caught my attention.

Since the entire excavator is controlled by a central computer (called the "Centurion" system) it makes sense that they would have the software guys on-hand.  The crew ran into a couple very major problems:

• A software bug was preventing the main drum (the part that raises and lowers the digging arm) from turning/moving at all
• A software "typo" (as described by the software engineer working on-site) was preventing the excavator from moving its caterpillar tracks (preventing any movement at all of the rig)

What was astonishing to me was the WAY in which these guys went about debugging:

1. Plug in a laptop to the excavator''s computer system
2. Open up some kind of IDE (couldn''t tell what it was or the language from the TV screen)
3. EDIT THE CODE DIRECTLY ON THE EXCAVATOR
4. Compile
5. Test if the code change fixed the specific problem (it did)
6. Fix other problems that arose as a result of the first code fix (there were several, including one that could cause one of the motors to catch on fire!!)
7. Call it good and continue

Now, these guys were in a time crunch with a $10 million piece of equipment and they had to get it done, but I have to say: Where''s the rigorous QA process?

At my place of work, we try to avoid the scenario of making code changes on a live/production system because you never know the full ramifications of any change you make.  Even after extensive testing in a staging environment, critical bugs can still arise.

It was just kind of a shock to me that:

1. These guys had such serious/critical bugs that they didn''t know about (they gave me the impression that they had just written the code that morning!)
2. They (and their customer) were totally comfortable with making changes right on the live system

This kind of thing makes me think a lot harder about industries where software plays a much more critical role, such as medical monitoring systems and equipment...  "Sorry about the defibrillator that fried your heart, turns out we put that damn decimal place one spot too far to the right...."