This Code Goes to Eleven

Moving from Blogger to my own server

noreply@blogger.com (Jonathan Holland) — Tue, 27 Jan 2009 14:37:00 +0000

I have relocated the blog to my own custom server.

From now on, you will be able to follow this blog at:

http://www.gfilter.net

Graphing Reddit Language Preferences

noreply@blogger.com (Jonathan Holland) — Sun, 11 Jan 2009 21:01:00 +0000

Programming Reddit recently had a survey of "favorite" languages with some surprising results.

I took the time to enter each "positive mention" of a language into Google Spreadsheet (I also wanted to play with that, I'm mildly impressed though its charting ability is weak at best.)

Results (Click for large image):

An interesting trend has developed here. I found that the the most maligned languages on Reddit had surprisingly high showings in this thread. C#, Java, C++, and Perl all ranked much higher than the more esoteric languages that are often advocated there.

Pythons current place at 2nd place is no surprise, and it is well deserved, but I was very surprised by the large showing of C# developers. They seemed to come out of the woodwork. The usual anti C# trolls actually made no showing at all, further convincing me that they aren't actually serious programmers regardless.

When you remove all of the languages that received less than 3 honorable mentions, It is easy to see that the massive majority of Reddit users prefer C#, Python, and C.

Not the often praised Haskell, Erlang, Scala or Lisp, but regular "get work done" languages. ~~This is a great thing, and shows a resurgence of actual developers to Reddit, and not head-in-the-clouds academics.~~

Edit: The above sentence appeared to be misinterpreted by all, so I thought I'd clarify.

I'm happy to see other people with similar interests as me, people who actually write the software the world uses, as opposed to the people who invent the tools necessary to write the software. Huge respect to academics, but as a software developer, and not computer scientist, I am happy to find others of a like mind.

In my world, I don't have 15 years to invent a compiler, I have 6 months to get from business case to shipped. I sometimes consider academics as out of touch with the realities of commercial business, hence the "head-in-the-clouds" statement.

Benchmarking the CLR vrs the JVM

noreply@blogger.com (Jonathan Holland) — Sat, 26 Jul 2008 18:42:00 +0000

I've found that there are lots of flame wars regarding JVM/CLR performance, but very little solid data, so I thought I'd try running a benchmark of my own.

I decided the first benchmark would be sorting using a bubble sort. The bubble sort is highly inefficient, so it is a good demonstration of memory management and integer arithmetic.

I also wanted to see how well the JIT's would handle method by method optimization, so I wrote a version that used methods for each runtime, as well as a version that was entirely inline.

My theory was that the inline version would prove to be slower than the method invoking versions due to JIT optimizations when calling methods. In reality, it was even more apparent. However, when I did disable the JIT optimizations on the CLR by using a debug build, the inline CLR version was much faster than the method version.

This data was generated on my 2.4ghz laptop running Windows XP. I used the .NET 2.0 CLR, and JRE 1.6.0.5 (Which just happened to be the one that came with Eclipse). The Y axis is milliseconds.

The benchmark is performing a bubblesort on a 10,000 integer set, 100 times.

It shows that the CLR is a slight winner, at least in doing these operations. The big surprise was the speed difference the JVM JIT makes when optimizing methods.

Even the unoptimized CLR version was only slightly slower than the JVM.

The surprising lesson learned here is that premature optimization by inlining methods and unrolling loops may actually result in slower performance on the JVM.

If anyone wants to run these benchmarks on their machine, the full source is here.

Normalize First

noreply@blogger.com (Jonathan Holland) — Tue, 15 Jul 2008 16:43:00 +0000

Sometimes Jeff Atwood does more harm than good. I wonder how many people will misunderstand his latest post.

I'm not positive that even he understands his latest post.

Take a look at his example query:


select * from Users u
inner join UserPhoneNumbers upn
on u.user_id = upn.user_id
inner join UserScreenNames usn
on u.user_id = usn.user_id
inner join UserAffiliations ua
on u.user_id = ua.user_id
inner join Affiliations a
on a.affiliation_id = ua.affiliation_id
inner join UserWorkHistory uwh
on u.user_id = uwh.user_id
inner join Affiliations wa
on uwh.affiliation_id = wa.affiliation_id

He argues that using 6 joins to pull together data on users is excessive, while missing the true point that 3NF (Then again, his "normalized schema" isn't even 2NF) enforces data integrity and ease of maintenance, not performance.

(Also, his join returns a boatload of duplicate data)

Normalize first. Denormalize only when its the last resort.

The scary thing is that people are going to read Atwood and then decide that their 200 column mega table is a good idea.

Its always Windows fault!

noreply@blogger.com (Jonathan Holland) — Thu, 24 Apr 2008 18:02:00 +0000

Jeff Atwood has been providing me with a lot of blogging material lately, I want to revisit his article that I talked about yesterday to study something that amused me greatly.

The common knee jerk reaction to Jeff's abysmal PHP/Wordpress statistics was that it was Windows fault, because he was running the site on a virtualized Server 2008 using IIS7.

As everyone knows, IIS is a horrible web server, the worst ever made, and Windows Server is really just a desktop OS with a fancy name and a higher price tag...Right?

This sort of knee jerk reaction is dangerous, because not only is it incorrect (How would the platform affect the number of queries being performed), but it also makes the commenter look, to put it nicely...stupid.

But, I was curious. I wanted to see how fast PHP was on IIS7, and I wanted to see some benchmarks of mySQL running on Windows versus mySQL running Linux.

However, I couldn't find any good benchmark results on mySQL. I found some interesting comparisons of mySQL versus SQLServer running on Windows (Guess who wins by a mile?), but it seems like nobody wants to run benchmarks between platforms. If you have or know of a benchmark, post it.

As far as PHP's performance on IIS7, it is actually very fast, when configured correctly.

I'm lifting some benchmarks from Bills IIS blog.

Here is PHP running through ISAPI, which means that IIS will multi thread it like it does ASP.NET. This can be somewhat unstable because a lot of PHP code is not written to be ran on multiple threads. This is pretty much how PHP runs on IIS6.

You can see that on Bills Vista laptop, he is getting about 60 requests per second. Not bad for just running on a dev box considering he is running the client software and the server on the same box. I'd say its safe to double every number he produces for a "in the wild" benchmark.

However, IIS7 now supports fastCGI, so lets rerun that benchmark using fastCGI. This will also be more stable, because it will be running on a single fastCGI thread.

With fastCGI setup, Bills little dev laptop is now pushing over 100 RPS. Not bad at all (again considering he is running the client software on the same CPU as the server), but we can do a LOT better.

IIS7 has kernel level caching abilities, so lets go ahead and enable that:

Notice that the scale of the graph has changed. This little laptop is now handling 6,000 RPS. I'm a little impressed with IIS7, you should be to :)

So we can rule out PHP/Windows as being the slow culprit, and we are on the fence if mySQL is slower on windows. I'm waiting for proof on that.

All this said, it will do nothing to prevent the knee jerk reaction of nonsense that is so prevalent on online communities. You can fight ignorance all you want, but I guess you can't fix stupid.

Why Relational Databases end up being the bottleneck

noreply@blogger.com (Jonathan Holland) — Wed, 23 Apr 2008 17:24:00 +0000

These days it is all the rage to diss on RDBMS. Just surf over to Digg or Reddit and you'll see lots of the following:

They don't scale well

There is relational/object impedance problems

They use massive amounts of CPU time

Performing table joins is slow

The list could go on and on. All of the cool kids are hyping new non relational databases such as SimpleDB and CouchDB, or even Googles BigTable.

I'm not in that camp. I do understand the shortcomings of a relational database, but I also know its strengths.

Personally, I don't use mySQL, and use SQL Server for my projects, and I have yet to have a scaling issue with it, so I didn't understand why people always claim that the database is the bottleneck in their application.

However, I finally understood because today Jeff Atwood blogged about Wordpress (One of the flagship LAMP products).

Wordpress in its unpatched and default state performs 20 queries to retrieve the posts on the front page.

In comparison, Codeblog performs 4, and I was unhappy with that, but that was due to trying SubSonic out instead of hand rolling my own database layer.

So, I gave Wordpress the benefit of the doubt, those 20 queries must be important right?

Wrong again, take this example from WordPress.


SELECT SQL_CALC_FOUND_ROWS  wp_posts.* 
FROM wp_posts  
WHERE 1=1  
AND wp_posts.post_type = 'post' 
AND (wp_posts.post_status = 'publish')  
ORDER BY wp_posts.post_date DESC LIMIT 0, 10

And then:

SELECT FOUND_ROWS()

And then:

SELECT post_id, meta_key, meta_value FROM wp_postmeta WHERE 
post_id IN (3,1) ORDER BY post_id, meta_key

Can you count the WTF's there? Did the authors have no clue about normalization and writing efficient joins? There are no relationships between posts, comments and authors, instead they just keep mindlessly querying away.

Of course, the saddest part is that the solution is not to fix their database, its to instead install a caching plug in to hide the fact that their database and supporting code SUCKS.

The bottom line is don't tell me RDMBS can't scale if you can't write a decent query or design a normalized database schema.

Unless you are performing a complex 10 table join, its will still be cheaper than opening 10 database connections and then sorting it all out in your code.

Relational databases are not the bottleneck. Crappy programmers are, which is what I suspected all along.

GFilter open beta

noreply@blogger.com (Jonathan Holland) — Fri, 11 Apr 2008 02:33:00 +0000

GFilter has been a small project that I began this week, and I am now opening up for beta. Please drop any bug reports as a comment here.

The concept behind GFilter is simple. GFilter allows you to create a personal blacklist of sites that you do not want to show up when you search the internet. This means no more Experts Exchange when you are trying to find a handy regular expression etc...

Additionally, sites that are especially unpopular across users will be automatically removed from any search, so the collective force of GFilter users will sanitize the web.

Try it out, stick as your homepage for a few days and drop me a note with any defects/suggestions. This is an experimental project designed just for fun!

http://www.gfilter.net

As a side note, I desperately need a designer to come up with a good logo for this, the cliche web 2.0 logo works fine as a placeholder, but it needs to go now :)

Domain Objects and DataReaders

noreply@blogger.com (Jonathan Holland) — Mon, 24 Mar 2008 19:58:00 +0000

Its been a very long time since I've written on this page, but it has not been because I am lazy.

Being a .NET developer, I try to give back to the community as much as I can, but the internet as a whole is rather critical of us .NET developers, and sometimes maintaining a blog can be a rather thankless and frustrating experience.

I decided to take some time off from blogging, to tackle a handful of difficult programming projects and to come back when I was feeling more refreshed.

I have been working on an application framework for some time, and I thought that a small snippet from that would be beneficial to my readers.

A common practice when designing a N-tiered framework is to create custom domain (or business) objects that are responsible for populating themselves from raw datareaders.

For example, you may have a database table that represents a "Customer". This approach would create an object that models the table schema as a strongly typed class. My usual technique to populate such a class is to pass a database row in the form of a IDataReader to the class constructor.

However, you almost always end up in a scenario where the stored procedure that is ultimately responsible for the creation of the IDataReader may only return a portion of the columns that the domain object expects.

Because of this, people advocate "defensive" coding techniques, where you validate the existence of each column before attempting to read and assign it to a class property.

Because IDataReader (and its derivatives, such as SQLDataReader and ODBCDataReader) do not expose a "HasColumn" property, I have witnessed some creative and horrible approaches to this technique:

    1 try

    2 {

    3     this.CustomerName = reader["CustomerName"].ToString();

    4 }

    5 catch (IndexOutOfRangeException)

    6 {

    7     this.CustomerName = string.Empty;

    8 }

Imagine this code, repeated for each column that may have been returned in the DataReader. Not only is it excessively verbose, but it violates a cardinal rule: Utilizing exceptions to control program flow.

Exceptions are a good thing, but using them in this fashion is a poor design choice. Each time an exception is thrown and caught, the call stack must traversed and a great deal of overhead is added on a per column basis.

Lets see if we can do better.

The first order of business is to refractor the column checking logic into a static helper method. There is no need to repeat this code for each column. I already had a static Utility class in my database namespace, so I placed this method there.

The second order of business is to take a page out of the TryParse notebook, and utilize an output parameter to pass our domain object variable. The new methods signature is quite obvious as to how this method will work:

    1 public static void ReadColumn(ref SqlDataReader reader, string columnName, out string column)

The current SqlDataReader will be passed by reference to this method in addition to passing the desired column name and finally the actual variable used within the domain object.

I created overloaded versions of this method to handle boolean, integer, string, and DateTime data types, to simplify even more the logic required in the population method.

Here is an example of the string method:

    1 public static void ReadColumn(ref SqlDataReader reader, string columnName, out string column)

    2 {

    3     column = string.Empty;    

    4     if (checkColumn(ref reader, columnName))

    5     {                

    6         column = reader[columnName].ToString();

    7     }

    8 }

As you can see, this is a very simple method, and the other overloaded methods are just as simple, containing an additional TryParse call in them to ensure that they can successfully cast the columns contents into the desired data type.

This leaves just one snippet of code remaining, the private helper method "checkColumn".

    1 private static bool checkColumn(ref SqlDataReader reader, string columnName)

    2 {

    3     reader.GetSchemaTable().DefaultView.RowFilter = "ColumnName='" + columnName + "'";

    4     return (reader.GetSchemaTable().DefaultView.Count > 0);

    5 }

IDataReader exposes a method that can return its schema in the form of a DataView object. Since DataView objects can be filtered using RowFilter, this method is able to create and filter the view by the desired column name. Finally, I check to see if there are any rows in the filtered view. This ensures that this column does exist in the DataReader.

Finally, jumping back to our domain objects populate code, we can replace all of the heavy duty defensive coding code with a simple and clean method call:

    1 SQLServer.Utility.ReadColumn(ref reader, "CustomerName", out this._customerName);

If anyone knows of a more efficient way to do this, please let me know. I am always a fan of optimizing out inefficiencies.

Software, Cellphones, and Upgrading

noreply@blogger.com (Jonathan Holland) — Mon, 31 Dec 2007 18:56:00 +0000

The wireless telecom industry has mastered marketing.

They are one of the few industries that can convince people throw out a perfectly functional product every year or so, for the next years model, all the while rarely adding "must have" features, and usually shortening battery life in the process.

The phone at the right, the Nokia 5190, was one of the first massively adopted cell phones. It featured digital and analog calling, good battery life, and if my memory serves me right, even text messaging.

Cell Phones have a fairly singular purpose, they should make and receive phone calls, and do it well.

Yet the Cell Industry has convinced the world that we should shell out several hundred dollars every year or so for the latest and greatest model.

I tried it, I switched the Windows Mobile powered T-Mobile Dash PDA phone for a few weeks, but eventually I went back to using my old standby, a simple Samsung flip phone, because the feature bloat of the PDA phone made doing what I really wanted to do (actually calling people) more difficult than my old phone.

How is it, that the wireless industry can charge more for phones that add features that most people don't use, and still be as popular as rock stars?

What is the secret?

Software upgrades are very similar to cell phone upgrades. Upgrading software is usually a somewhat apprehensive experience. The new version often runs slower, takes up twice the hard drive space, and adds few new features to make the upgrade worthwhile at all.

Winamp and Paint Shop Pro are great examples of this.

However, with a few rare exceptions (I.E. Anything produced by Apple), people only upgrade software when they absolutely have to.

So I ask my readers, what is it that compels people to upgrade, and why has the software industry not figured this out?

If someone does, they have the potential to be very successful.

What exactly do you save with Dynamic Languages?

noreply@blogger.com (Jonathan Holland) — Thu, 27 Dec 2007 18:54:00 +0000

Steve Yegge recently published a manifesto that claims that design patterns and refactoring only bloat Java code to the point of being unmaintainable. He cited his 500k LoC Java game as an example.

He has since decided to rewrite his game in Rhino (Which is a JVM driven version of EcmaScript), attributing the dynamic nature of Ecmascript as superior for keeping the code base small, over a rigorously typed static language such as Java.

I would never argue that Java is not a verbose language full of boilerplate code, I work with .NET, which suffers from the same phenomena.

However, I will argue that Yegge is flawed when he compares total lines of code with both maintainability and complexity.

Comparing snippets of Java or C# to snippets of Ruby/Perl/Python etc are decieving. Sure the dynamic languages may accomplish in one line what a static language takes 5 lines, but the static language is instantly apparent on its purpose, while the dynamic language works by using behind the scenes framework magic.

Besides, if you find yourself repeating that same 5 lines over and over, then its time to apply the DRY principle and refractor it into a method. Now your static language can do exactly what the dynamic language can, and as an added advantage, you can always grok the method to see what exactly is going on. From a maintenance standpoint, this is a huge advantage.

Dynamic languages are not a magic bullet that instantly solves maintenance woes, in fact, I believe they are the complete opposite. One only has to look back 5 years to classic ASP and Dynamic VBScript to see the complete frustration that dynamic development causes on large projects.

A properly designed application using a static language such as Java or C# might easily hit the 500k LoC mark, but with proper design and abstraction, the actual code base can easily be split into manageable 10k LoC assemblies.

At that point you are only maintaining small libraries that reference each other, instead of a super massive black hole of spaghetti code.

I believe that both forms of languages have their purpose, but I do not buy into the recent dynamic language hype. I have been developing in various languages long enough to remember previous dynamic language hype, and the resulting messy applications that came from it.

A final note that I do not believe Yegge touched on (mostly because I didn't read all of his 400 page rant) is that dynamic languages must be developed using test driven methodologies. Applying TDD to static languages is great as well, but the compiler adds an additional level of checks.

What this means in the real world is that a properly designed application will need to have unit tests to ensure that all runtime functionality is carefully checked. The end result is thousands of lines of test code that must be written to replicate the functionality of a compilers type checker*.

^{* I still advocate TDD when using statically typed languages, you just don't need to do as much.}

How to find local Data Sources on your server

noreply@blogger.com (Jonathan Holland) — Thu, 20 Dec 2007 18:07:00 +0000

In between preparing for the holidays and taking care of my new son (Who turned one month old yesterday), I have been working on writing an installation wizard for CodeBlog.

Part of the difficulty of installing custom database driven sites onto remote servers is the unpredictability of the server configuration. I am trying to ease that pain by automating as much as possible the initial configuration.

One major hurdle is coming up with the correct connection string to SQL Server. I am attempting to make this a easy process by allowing the user to select the data source and database from drop down menu's.

I thought I'd share a handful of code snippets that makes this possible:

    1 private DataTable GetDataSources()
    2 {
    3     DbProviderFactory factory =
    4         DbProviderFactories.GetFactory 
    5         ("System.Data.SqlClient");
    6 
    7     DbDataSourceEnumerator dataSourceEnumerator = 
    8         factory.CreateDataSourceEnumerator();
    9 
   10     if (dataSourceEnumerator != null)
   11     {        
   12         DataTable dataSources = dataSourceEnumerator.GetDataSources();
   13         return dataSources;
   14     }
   15     else
   16     {
   17         throw new Exception("Something bad happened");
   18     }
   19 }

This method returns all available data sources on the local server. Obviously, if the SQL Server is located on a different box, this won't work, so I have implemented a manual entry text box as well.

The method returns a data table that can be bound to a drop down list. However, because you need to concatenate the value of two columns, you cannot use regular data binding, instead use a method similar to this:

    1 private void BindDataSource()
    2 {
    3     DataTable dt = GetDataSources();
    4     foreach (DataRow dr in dt.Rows)
    5     {   
    6         ListItem currentItem = new ListItem();
    7         currentItem.Value = dr["ServerName"] + "\\" + dr["InstanceName"];
    8         currentItem.Text = dr["ServerName"] + "\\" + dr["InstanceName"];
    9         ddlDataSources.Items.Add(currentItem);
   10     }
   11     if (ddlDataSources.Items.Count > 0)
   12     {
   13         BindDatabaseList();
   14     }
   15     else
   16     {
   17         ddlDataSources.Items.Add("No DataSources found.");
   18     }
   19 }

Once the user has selected the proper data source, I wanted to populate a second drop down list with all available databases. The following snippet creates a list of available databases on the data source:

    1 private void BindDatabaseList()
    2 {
    3     SqlConnectionStringBuilder builder = BuildConnectionString();
    4 
    5     builder.InitialCatalog = "master";
    6 
    7     SqlConnection connection = new SqlConnection(builder.ConnectionString);
    8     SqlCommand command = new SqlCommand();
    9     SqlDataReader dataReader;
   10 
   11     connection.Open();
   12 
   13     command.CommandText = "SELECT NAME FROM master..sysdatabases ORDER BY NAME ASC";
   14     command.Connection = connection;
   15     dataReader = command.ExecuteReader();
   16 
   17     ddlDataBase.Items.Clear();
   18 
   19     while (dataReader.Read())
   20     {
   21         string dbName = (String)dataReader["name"];
   22         if (dbName != null)
   23         {
   24             if (dbName != "master" &&
   25                 dbName != "msdb" &&
   26                 dbName != "tempdb" &&
   27                 dbName != "model")
   28             {
   29                 ddlDataBase.Items.Add(dbName);                        
   30             }                    
   31         }
   32     }
   33     connection.Close();                        
   34 }

All of these little snippets combine to create a intuitive way to setup the initial database connection. It is a lot of work, but the result is a simple configuration screen.

Normally, I would avoid placing database code directly into front end code, but in the case of a run once installation script, it makes sense. Once the script has ran, the user will have to physically delete it off the server before CodeBlog will run. This is to prevent a malicious person from reconfiguring the database.

ASP.NET MVC RouteBuilder HTTPModule released!

noreply@blogger.com (Jonathan Holland) — Fri, 14 Dec 2007 03:54:00 +0000

The ASP.NET MVC currently stores all route information in global.asax. One of the first things I did when I began playing with the CTP was moving the routing rules into a HTTPModule.

However, I do not believe that configuration should ever be stored inside a compiled code file.

I blogged yesterday about my difficulty in building a dynamic route builder due to the Route object only accepting an anonymous type for the "defaults" property.

However, with the help of Eilon Lipton (One of the principle developers behind ASP.NET MVC), I was able to circumvent this limitation by using a custom class that inherited from CustomTypeDescriptor at the cost of having to write a lot of boilerplate code.

The final product? A simple HTTPModule that allows you to place your routing rules in web.config where they belong.

The binary and full source are available on the RouteBuilder CodePlex page.

Download and check it out. There are full (simple) installation and usage instructions in the zip file.

Huge thanks to Eilon for promptly answering my questions. This speaks volumes about Microsoft's dedication to the development community.

Please let me know if you have any issues using it, or how it can be improved.

ASP.NET MVC makes it impossible to dynamically build RouteTables?

noreply@blogger.com (Jonathan Holland) — Thu, 13 Dec 2007 00:56:00 +0000

Yesterday I finally installed Visual Studio 2008, for the sole purpose of studying the new ASP.NET MVC framework.

As it is currently designed, the MVC framework places all URL Routing rules into global.asax.

Personally, I feel that many applications will have dozens, if not hundreds of URL routing rules, so the first thing I did was create a HTTPModule and move the URL routing rules out of global.asax.

This worked great, but I find the concept of hard coding configuration into the source code rather primitive, so I began implementing a custom configuration section into web.config to handle URL routing.

Initial development went great, and it was not long before I had this in my web.config:

<RouteTable>
  <Routes>
    <addRoute Url="[controller]/[action]/[postId]" Defaults="action=Index,postId=(string)null"/>
    <addRoute Url="Default.aspx" Defaults="controller=Home,action=Index,id=(string)null"/>
  </Routes>      
</RouteTable>

The only caveat? My dynamic route building code did not work.

I had assumed that because Route.Defaults was an object type, it would be smart enough to let me stuff a key/value Dictionary into it containing the defaults values.

However, Route.Defaults only accepts an anonymous type, as you can see here in the debugger:

The C# compiler converts these anonymous types to strongly typed classes during compile time, so the Route class must rely on reflection to figure out what properties were created. In my opinion this is a rather inelegant abuse of a new technology, when a simply dictionary would have sufficed just fine.

A little googling found a blog post from Eilon Lipton championing this technique, and why they used in the MVC framework.

Granted, I am new to C# 3.0, and I don't fully understand all of its new features. But for the life of me, I cannot figure out how to construct an anonymous class during runtime, and if you cannot*, then there is no way to dynamically build route tables with the MVC framework as it is currently designed.

And that, I must say, is disappointing.

^{* Please tell me how to do this if its possible!}

Visual Studio 2008 and the "InitializingToolbox" bug.

noreply@blogger.com (Jonathan Holland) — Wed, 12 Dec 2007 17:55:00 +0000

With the new ASP.NET MVC CTP released, I finally had a reason to get around to installing the Visual Studio 2008 RTM.

I was excited to dig into the MVC framework and start blogging about it, except that I found Visual Studio 2008 was borderline unusable.

Opening a ASPX file would stall my system, spike my CPU/Ram usage and sit there frozen, with the message "Initializing Toolbox" in the status bar.

Obviously, this was unacceptable, so I searched for a way to fix this issue. I believe it is related to having multiple versions of Visual Studio installed on the same system. In my case, I have 2003,2005 and 2008 for various different projects I work on.

Regardless of the cause, I finally found the fix:

Navigate to: Documents And Settings\{UserName}\Local Settings\Application Data\Microsoft\VisualStudio.
You should see a directory named 9.0.
Rename or delete this directory.
Start Visual Studio 2008 and open a ASPX page. It should grind away for about 10 minutes.
Eventually it will open, and everything will be good from then on.

An odd bug for sure, but now that it is fixed, VS 2008 is quite nice. After I have some time to digest the MVC bits, I hope to be able to blog on my opinion of the new framework.

Setting up a SQLEXPRESS Database for use with ASP.NET

noreply@blogger.com (Jonathan Holland) — Sat, 08 Dec 2007 06:28:00 +0000

If you set up a database using SQLEXPRESS for use with an ASP.NET site, you may get an error message similar to:

The login failed. Login failed for user 'MACHINENAME\ASPNET'

The reason for this is because the ASP.NET Worker process runs under the ASPNET User account, and if the database is using Windows Authentication it will deny access to that user.

Fortunately, the fix is very simple. Since SQLEXPRESS does not have any graphical management tools, you can use osql.exe to setup your database to work with the ASPNET account.

Fire up your preferred shell and type:

osql -E -S [YOURMACHINENAME]\SQLEXPRESS -d [YOURDATABASENAME]

This will fire up osql and connect to your database.

At this point, you should see a prompt. Enter the following lines:

EXEC sp_grantdbaccess [MACHINENAME\ASPNET]
GO
EXEC sp_addrolemember 'db_owner',[MACHINENAME\ASPNET]
GO

At this point, your ASP.NET site will be able to connect to the database, however it may not be able to perform operations to it. You may need to grant privileges to the account.

This is done on a table by table basis, so go back to osql and type:

GRANT SELECT,INSERT,UPDATE,DELETE ON [TableName] TO [MACHINENAME\ASPNET]
GO

Do this for each table in the database, if you have any stored procedures, you will also want to grant execute privileges:

GRANT EXECUTE TO [MACHINENAME\ASPNET]
GO

With all that done, you should be completely set up to use SQLEXPRESS with ASP.NET.

The hidden ORM Tax and why profiling is a good thing.

noreply@blogger.com (Jonathan Holland) — Fri, 07 Dec 2007 17:27:00 +0000

I am a strong believer in not doing premature optimization while programming. Because of this, database performance has been on the back burner for CodeBlog, while I focused on getting the core built.

At this point, the engine is 99% functional, so I thought I'd step back and look at it from the performance standpoint.

As I have mentioned before, I used SubSonic as an Object Relational Mapper (ORM) to speed up the development of this project. In a nutshell, SubSonic employs the ActiveRecord pattern to build strongly typed classes and collections that correspond to tables and rows in the database.

SubSonic makes development a breeze, allowing me to quickly write a business layer that could manipulate the SubSonic generated objects and never have to worry about the underlying database. If I needed to do something that SubSonic couldn't handle, I wrote a stored procedure in the database and SubSonic would create a static class to call it.

Definitely a great tool for rapid development, however it is not without its drawbacks.

Yesterday, I set up a SQL profiler, interested in seeing how Subsonic was actually hitting the database on each page load. While I expected to see some inefficient queries (The natural by product of using ActiveRecord), what I did find was far worse:

    1 --Main Page:
    2 
    3 -- First Get All Posts that we have, this is to calculate out post paging
    4 SELECT COUNT([postID]) FROM [Post]
    5 
    6 -- Grab all the posts????
    7 SELECT TOP 100 PERCENT  [dbo].[Post].[PostID], [dbo].[Post].[CreatedOn], 
    8     [dbo].[Post].[CreatedBy], [dbo].[Post].[ModifiedOn], [dbo].[Post].[ModifiedBy], 
    9     [dbo].[Post].[Author], [dbo].[Post].[Subject], [dbo].[Post].[Text], [dbo].[Post].[UrlKey] 
   10     FROM [dbo].[Post] ORDER BY [CreatedOn] DESC;
   11 
   12 -- Now we grab the post Object again to get the URL to the post page
   13 SELECT TOP 100 PERCENT  [dbo].[Post].[PostID], [dbo].[Post].[CreatedOn], [dbo].[Post].[CreatedBy], 
   14     [dbo].[Post].[ModifiedOn], [dbo].[Post].[ModifiedBy], [dbo].[Post].[Author], [dbo].[Post].[Subject], 
   15     [dbo].[Post].[Text], [dbo].[Post].[UrlKey] 
   16     FROM [dbo].[Post] WHERE [Post].[PostID] = @PostID0 ORDER BY [PostID] ASC;
   17 
   18 -- Grab the Whole author object, all we really need is first name.
   19 
   20 SELECT TOP 100 PERCENT  
   21     [dbo].[Author].[AuthorID], [dbo].[Author].[CreatedOn], [dbo].[Author].[CreatedBy], 
   22     [dbo].[Author].[ModifiedOn], [dbo].[Author].[ModifiedBy], [dbo].[Author].[FullName], 
   23     [dbo].[Author].[PassHash], [dbo].[Author].[UserName], [dbo].[Author].[PostCount], 
   24     [dbo].[Author].[isAdmin] 
   25     FROM [dbo].[Author] WHERE [Author].[AuthorID] = @AuthorID0 ORDER BY [AuthorID] ASC;
   26 
   27 -- Grab all the comments, all we want is the count
   28 
   29 SELECT TOP 100 PERCENT  [dbo].[Comment].[CommentID], [dbo].[Comment].[CreatedOn], 
   30     [dbo].[Comment].[CreatedBy], [dbo].[Comment].[ModifiedOn], [dbo].[Comment].[ModifiedBy], 
   31     [dbo].[Comment].[PostID], [dbo].[Comment].[AuthorName], [dbo].[Comment].[AuthorEmail], 
   32     [dbo].[Comment].[AuthorWeb], [dbo].[Comment].[Subject], [dbo].[Comment].[Text] 
   33     FROM [dbo].[Comment] WHERE [Comment].[PostID] = @PostID0 ORDER BY [CreatedOn] ASC;

Without running the profiler, I had no idea that I was hitting the database that hard to just load the main page of CodeBlog.

An interesting note, the query that appears to be grabbing all of the posts actually uses SQL Server 2005 paging to only grab a handful posts, and I believe the SQL Profiler is getting confused. At least, I hope so.

Right off the bat, I see several improvements that I can make to prevent round trips to the database. For example, I have a helper method for the Post business object that generates a Rewrite Friendly URL. There is no need for this method to go back to the DB to get the UrlKey when we already have the entire post loaded as an object.

Additionally, there is no need to pull the comments from the database, when all we really need is the count, so I wrote an overloaded Fill method for the Comments as well.

    1 -- Grab the total number of posts
    2 SELECT COUNT([postID]) FROM [Post]
    3 
    4 -- Grab a page of posts
    5 SELECT TOP 100 PERCENT  
    6     [dbo].[Post].[PostID], [dbo].[Post].[CreatedOn], [dbo].[Post].[CreatedBy], 
    7     [dbo].[Post].[ModifiedOn], [dbo].[Post].[ModifiedBy], [dbo].[Post].[Author], 
    8     [dbo].[Post].[Subject], [dbo].[Post].[Text], [dbo].[Post].[UrlKey] 
    9     FROM [dbo].[Post] ORDER BY [CreatedOn] DESC;
   10 
   11 -- Grab the Author
   12 SELECT TOP 100 PERCENT  
   13     [dbo].[Author].[AuthorID], [dbo].[Author].[CreatedOn], [dbo].[Author].[CreatedBy], 
   14     [dbo].[Author].[ModifiedOn], [dbo].[Author].[ModifiedBy], [dbo].[Author].[FullName], 
   15     [dbo].[Author].[PassHash], [dbo].[Author].[UserName], [dbo].[Author].[PostCount], 
   16     [dbo].[Author].[isAdmin] 
   17     FROM [dbo].[Author] WHERE [Author].[AuthorID] = @AuthorID0 ORDER BY [AuthorID] ASC;
   18 
   19 -- Grab the number of comments
   20 SELECT COUNT([CommentID]) FROM [Comment] WHERE [Comment].[PostID] = @PostID0

Doing this dropped one call to the database, and cut down heavily on the amount of data returned. It is still less than optimal, but to further optimize would involve me extending the SubSonic methods for my own needs, and at that point, why even bother with using an ORM tool?

The sad truth of the matter is that everything queried for that page could be pulled with one trip to the database with a well executed JOIN query. Because ORM's prefer multiple trips instead of JOIN's, you end up with this form of inefficiency.

At the moment I am on the fence about using an ORM. While it has helped me rapidly build my application, I feel that under heavy use, I would have to go back and rewrite my database layer by hand.

If performance is what you need. Don't use an ORM. If you need rapid development to a small target audience, then ORM's are great, but even if you use one, always profile it to see where you can improve your performance.

Are you inadequate?

noreply@blogger.com (Jonathan Holland) — Tue, 04 Dec 2007 23:54:00 +0000

SecretGeek posted a little morale booster for us developers:

YOU ARE NOT INADEQUATE.
You do NOT have to refactor all your code.
You do NOT have to keep up with the latest news from microsoft, and know everything there is to know about longhorn, whidbey, avalon, XAML, indigo and star wars III.
You do not have to have perfectly de-coupled tiers in your technology independent SOA software.
You do not have to comply to every standard, achieve the perfect balance between maintainability and performance. Usability and familiarity.
You don't have to do "first things first every day"
You DO NOT have to memorize and understand every patten the gang of four have cataloged.
You do NOT have to read every technical blog, print out every technical article and learn every technical thing there is to learn.
You are beautiful just the way you are.
You are brilliant, interesting, wise and fun to be around.
You rock.

According to Jeff Atwoods 80/20 rule, if you are reading this blog, then you are already in the 20%. I am not saying that I am a top 20% developer, just that anyone who is actively reading programming blogs usually cares enough about their craft to not be inadequate.

It is easy to feel like a second rate programmer when you read programming blogs. Often I feel like topics go completely over my head when I try to decipher some of the more technologically advanced posts out there.

But if you are reading about programming, then you are learning...You may not be the worlds greatest programmer, but you are head and shoulders above people who program from 9-5 and then go home and watch TV.

The more you learn, the more inadequate you should feel. If you start to feel complacent, then you enter the dangerous stagnation that dooms developers in this fast paced industry.

My advice on not being inadequate?

Read blogs from people smarter than you.
Write your own blog.
Learn something new every day. Anything.
Program at home, on the weekends, while sleeping...you get my drift.

There are too many inadequate programmers who get by because they have found their niche. Don't fall into that trap. Become a dynamic developer. It is good for your career, and the community as a whole.

Extending your application by creating plugins.

noreply@blogger.com (Jonathan Holland) — Sun, 02 Dec 2007 19:12:00 +0000

CodeBlog would have been done long ago if I did not keep thinking of other idea's to stick into it.

This morning I was wondering on the best way to approach handling custom sidebar widgets, and it struck me that creating a simple plug-in system would not only be fun, but it would allow other people to develop widgets without having to rebuild the inner workings of CodeBlog.

After a half hour or so of tinkering, I came up with the basic concept for developing a CodeBlog plug-in, though there is a lot more to code out.

The basic concept:

Each plug-in is stored within its own assembly.
A common interface (ICodeBlogPlugin) is used to reference the plug-in.
A static factory method is used in CodeBlog to load and instantiate the plug-in.

Each Plug-In is a class library that references CodeBlog.Plugin.dll. This library provides an interface ICodeBlogPlugin that must be implemented by the plug-in class.

For testing, I used a very basic interface, but I will extend this interface to provide all the method signatures needed for an actual plug-in:

    1 public interface ICodeBlogPlugin
    2     {        
    3         string PluginName
    4         {
    5             get;
    6             set;
    7         }
    8 
    9         void Render();
   10     }

This interface is to be implemented by any plug-in class. For example, to test my idea, I created a new class library and added CodeBlog.Plugin as a reference:

    1     public class TestPlugin : ICodeBlogPlugin
    2     {
    3 
    4         private string _pluginName;
    5 
    6         /// <summary>
    7         /// PluginName Property required by ICodeBlogPlugin
    8         /// </summary>
    9         public string PluginName
   10         {
   11             get
   12             {
   13                 return _pluginName;
   14             }
   15             set
   16             {
   17                 _pluginName = value;
   18             }
   19         }
   20 
   21         /// <summary>
   22         /// Default Constructor
   23         /// </summary>
   24         public TestPlugin()
   25         {
   26             PluginName = "TestPlugin!";
   27         }
   28 
   29         /// <summary>
   30         /// Render Method required by ICodeBlogPlugin
   31         /// </summary>
   32         public void Render()
   33         {
   34             HttpContext.Current.Response.Write(PluginName);
   35         }
   36     }

To load the plugin into a class instance in the CodeBlog Core. I also added a static class called PluginFactory into CodeBlog.Plugin:

    1     public static class PluginFactory
    2     {
    3         public static ICodeBlogPlugin LoadPlugin(string pluginName)
    4         {
    5             Type theType = Type.GetType(pluginName);
    6             return (ICodeBlogPlugin)Activator.CreateInstance(theType);
    7         }
    8     }

Of course, in actual production code, there needs to be exception handling implemented, but this was just some quick test code. Eventually, I will write a plugin loader framework and configuration file, but for now, quickly mocking up some code to test load the plugin was trivial:

    1 ICodeBlogPlugin TestPlugin;
    2 TestPlugin = PluginFactory.LoadPlugin("CodeBlog.TestPlugin.TestPluginClass,CodeBlog.TestPlugin");
    3 TestPlugin.Render();

The potential here is great. A developer can implement the ICodeBlogPlugin interface and create a plug-in that will work directly in CodeBlog. A end user will only have to drop the DLL into the /bin directory and add the assembly name to a configuration file and the plug-in will be ready to use.

This is definitly a fun feature that I hope will be leveraged to its full potential.

Microsoft and Innovation

noreply@blogger.com (Jonathan Holland) — Fri, 30 Nov 2007 03:27:00 +0000

The commenter's on Jeff Atwoods latest post tend to fall into two camps. On one side you have the people who make their living with Microsoft products, most of them are also open source advocates, without being mouth breathing fan boys.

On the flip side, you have the Anti-Microsoft trolls. These people are often there just to take potshots at Microsoft. Ironically, most of them can not agree on what technology they do endorse, considering the amount of flame that goes around on the popular open source haunts.

It is the latter camp that prompted Chris Pratley (A project manager for Microsoft Office) to write this on his blog:

I've been a little gun-shy of blogging about Word for fear of being inundated by what are as far as I can tell a gang of "net thugs" who roam the net making outrageous claims about Microsoft and its behavior, motives, etc in every public forum they find (little of which information they are privy to or have evidence for, and which I find personally offensive, not to mention incorrect - since they often are implicitly about me if the talk is about Office and therefore I for one know them to be incorrect). But enough about that - let's just dive in and see what happens. Hopefully the net-dwelling paranoid delusional conspiracy theorists won’t descend upon me… :-)

It doesn't take much wit to see past the trolls weak arguments, but I was particular struck be a reoccurring theme on Jeff comments.

This theme in a nutshell was:

"Microsoft does not Innovate, they only copy."

While this statement is laughably ridiculous, I thought I'd try to think of a handful of innovations that have come directly from Microsoft. Here, in no particular order, are just a few thing that the "evil empire" came up with first.

The Taskbar

Popularized with Windows 95, the taskbar was actually a feature of Windows 1.0. A crude representation of active tasks laid were represented in a horizontal bar on the bottom of the screen. This was two years early than the Acorn Author operating environment that many Anti-Microsoft people cite as the first task bar. The taskbar was gone from Windows until Windows 95.

In the early 90's, I had a chance to tour the Microsoft Redmond campus, and play with what was then known as Cairo. While Cairo never saw the light of day, its unique user interface was carried over for Windows 95.

Real Time Spell Checking

This was first featured in Microsoft Word 6.0, and has since been incorporated into every word processing program on the planet.

Rapid Application Development

RAD was a hugely popular industry buzzword during the 90's, and it was born with Microsoft Visual Basic.

Introduced in 1991, Visual Basic was a innovative new way to rapidly develop applications and it turned the programming industry on its head. The closest competitor to Visual Basic (Borland Delphi) was not released until 1995.

OLE and COM

OLE was originally designed by Microsoft in 1990 by the Microsoft Office team out of necessity. It was used to allow real time embedding of Excel documents into Word, and vice versa. This paved the way for what became known as COM (Component Object Model) a technology that allowed any COM compliant object to be used by any application. COM allowed reuse of objects with no knowledge of their internal implementation because it provided interfaces that are separate from implementation.

COM is heavily adopted and is used in nearly every windows application even to this day and was actually imitated by the open source movement with CORBA.

.NET and the Microsoft CLR (and DLR)

The CLR (Common Language Runtime) was not the first JIT compiling virtual machine, but it was innovative because it allowed an application to be built in any .NET language (or a combination of them) with seamless integration. Want to use VB for the front end, C# for the database layer, and C++ for some intensive graphics calculations? No problem!

The DLR continues this practice by creating a platform for dynamically typed languages such as Ruby and Python.

Active Desktop

Introduced with IE 4.0 and Windows 98 and powered by COM/ActiveX technology, Active Desktop was Microsoft's vision of integrating desktop applications with web applications.

Litigation kept Microsoft from fully leveraging the concept, but the idea lives on now in many open source projects :)

XMLHTTPRequest and AJAX

Believe it or not, the radical technology that changed the web and the technology that powers Gmail was stuck into IE 4.0 without any fanfare.

The Microsoft Outlook team needed a way to communicate behind the scenes on their new Microsoft Web Mail client, so they built an ActiveX component for IE 4.0. This little component remained under the radar for several years, before the rest of the world discovered its power and AJAX was born.

I wonder if Google has ever said "thank you".

Windows Powershell

Powershell is the long awaiting replacement for the default windows shell and is different from any scripting shell environment ever created.

Scripting is fully object oriented by leveraging the .NET CLR. Objects (known as cmdlets) can have their output piped with a single keystroke. If you have not had a chance to check out PowerShell yet, check it out. It is amazing.

This is just the tip of the iceberg on Microsoft innovations. Microsoft employs some of the brightest minds in the industry, and they and throw out more innovations every day than any of the Anti-Microsoft trolls have ever come up with.

So, regardless of what operating system you are reading this post on. Next time you visit an AJAX enabled website, or correct your spelling in a document, remember that Microsoft innovation is the reason you have it, and perhaps give them a the credit they do deserve.

Linux killed the One Laptop Per Child project

noreply@blogger.com (Jonathan Holland) — Wed, 28 Nov 2007 03:34:00 +0000

Unless you have been living under a rock, you have probably heard of the One Laptop Per Child foundation.

Their goal was to develop a $100 laptop (Called the XO) and give it to children in developing countries . The project was highly heralded and many governments signed on to buy thousands of these laptops.

Part of the concept was to use Linux as the base operating system, partially to avoid having to pay licensing costs for Microsoft Windows, and also to develop a custom environment that children who were not familiar with computers would find easy to use.

The end result was a interface called "Sugar" that was unlike any known computer interface in the developed world. Written in Python, it was definitly unique, though some people find its UI strange and counterintuitive.

After all the fanfare, the foundation was not able to meet the $100 goal, and is now offering the laptop for close to $200.

At that price, it competes directly with the Intel Classmate. A similar laptop that is available with either Linux or Windows XP.

It is no surprise that countries are now backtracking on their promises to order large quantities of the XO. Many people are blaming the windows powered Classmate for the XO's demise. I believe it is the opposite, the XO's demise was the fact that it was a proprietary Linux machine with a unusual interface.

Children are the future of developing countries, and the leaders of these countries want to adopt modern first world ways.

Dumbing down a laptop does not teach these children any essential skills that they can use in the future.

A generic laptop running a widely used operating system does. The learning curve may be steeper, but my four year old daughter was able to teach herself how to navigate around a web browser to access her favorite kid sites. If my four year old can, than any kid could.

Government leaders don't want to hold their country back with a useless and limited device, they want the children to be ready to enter the first world prepared.

The XO is nothing but a limited and fancy toy. It was an excellent vision, but I believe the zeal of creating a radical new experience was its downfall.

There is no point in Client Side Hashing

noreply@blogger.com (Jonathan Holland) — Tue, 27 Nov 2007 02:46:00 +0000

A while back, Jeff Atwood blogged about password security. His post caused a good bit of controversy and the comments and back links highlighted that the concept of password security is poorly understood by most developers.

I found the chaos somewhat amusing, as I was already been using a technique of Hash(SALT + ClearText) for my projects.

The reason for using a SALT is to create a long enough hash to make it impossible to break with a rainbow table. The salt does not have to be unique, though that does not hurt. The salt can be public, there is no need to conceal it.

I was recently examining a Vbulletin forum's Javascript code when I noticed that the login code performs a MD5 hash on the password on the client, before submitting the hashed password back to the server.

I am sure the original developer who wrote that was concerned about a clear text password being intercepted, and thought his clever scheme of hashing would fix that.

It didn't. It only made it worse.

The server side validation code is expecting a hash, if someone were to intercept the hash, they are as home free as having the clear text password sent. It is trivial to use FireBug to override Javascript and submit a form manually.

So at best, client side hashing does not improve the situation at all, however it also exposes the hashing technique used (And in the case of Vbulletin, uses one of the weakest, most flawed techniques known: MD5).

This means that even if you are using a server side salt, the attacker now has a good guess towards the hash algorithm used, and won't have to waste time generating rainbow tables for other algorithms.

Overall, never hash on the client. Send your password in clear text*. If you are concerned about doing that, then the only thing you can do is HTTP Encryption using SSL.

^{*Do hash and salt the password on the server though.}

Adding RSS Syndication to CodeBlog

noreply@blogger.com (Jonathan Holland) — Sun, 25 Nov 2007 21:04:00 +0000

RSS stands for "Really Simple Syndication" and for once, it is a name that actually delivers.

RSS has lots of features, however implementing it is dead easy. So easy in fact, that it took less than 10 minutes to add it to CodeBlog, and I had never worked with RSS before.

The concept behind RSS is to provide a link that feed readers can access to get the latest content from a dynamic site.

The RSS file is an XML document, with a minimalistic schema:

    1 <rss version="2.0">
    2     <channel>
    3         <title>Website Feed Title</title>
    4         <link>Website Feed URL</link>
    5         <description>Website Feed description</description>
    6         <ttl>Time in Minutes to Refresh Cache</ttl>
    7         <item>
    8             <title>Post Subject/Title</title>
    9             <description>Post Description / Full Text of Post</description>
   10             <link>Permalink to Post</link>
   11             <pubDate>Date Published</pubDate>
   12         </item>
   13     </channel>
   14 </rss>

Of course, RSS has much more to it, but this all that is required to syndicate blog posts. For more information, take a look at the full specification.

To implement this in CodeBlog, I created a ASPX page called RSSFeed.aspx and removed all content except the Page directive.

I used the Page_Load event in the code behind to generate the XML:

    1 protected void Page_Load(object sender, EventArgs e)
    2 {
    3     Response.Clear();
    4     Response.ContentType = "text/xml";
    5     XmlTextWriter rssXml = new XmlTextWriter(Response.OutputStream,Encoding.UTF8);
    6 
    7     rssXml.WriteStartDocument();
    8 
    9     rssXml.WriteStartElement("rss");
   10     rssXml.WriteAttributeString("version", "2.0");
   11     rssXml.WriteStartElement("channel");
   12 
   13     rssXml.WriteElementString("title", CodeBlog.Configuration.ConfigurationManager.BlogTitle);
   14     rssXml.WriteElementString("link", CodeBlog.Configuration.ConfigurationManager.BaseDomain);
   15     rssXml.WriteElementString("description", CodeBlog.Configuration.ConfigurationManager.BlogDescription);
   16     rssXml.WriteElementString("ttl", "60");
   17 
   18     PostCollection posts;
   19 
   20     posts = PostService.GetMostRecentPosts(10);
   21 
   22     foreach (Post post in posts)
   23     {
   24         rssXml.WriteStartElement("item");
   25         rssXml.WriteElementString("title", post.Subject);
   26         rssXml.WriteElementString("description", post.Text);
   27         rssXml.WriteElementString("link", PostService.GetPostURL(post.PostID));
   28         rssXml.WriteElementString("pubDate", post.CreatedOn.ToShortDateString());
   29         rssXml.WriteEndElement();
   30     }
   31 
   32     rssXml.WriteEndElement();
   33     rssXml.WriteEndElement();
   34     rssXml.WriteEndDocument();
   35     rssXml.Flush();
   36     rssXml.Close();
   37     Response.End();
   38 }

The .NET framework has excellent built in XML tools so there is no need to worry about outputting valid XML, the framework does it for you.

The foreach loop creates an <item> element for each blog post returned by the business object.

Overall, RSS has been the easiest feature I have added to CodeBlog to date. The actual blog engine will be available in open source form for download next week.

Community Matters

noreply@blogger.com (Jonathan Holland) — Sat, 24 Nov 2007 22:15:00 +0000

It is difficult to blog on ASP.NET.

Many of the times that I submitted a blog post to the popular social networks (Digg, Reddit, Dzone etc) it gets buried by open source advocates, yet they don't even bother to click through to read it. The internet is definitly skewed in a unfairly biased anti Microsoft light.

However, there are places where Microsoft topic blogging is welcome. Sites such as DotNetKicks provide a refuge and community for the small and dedicated group of Microsoft programmers.

So I was very surprised to be attacked by a fellow ASP.NET programmer today regarding yesterdays blog post.

Its absolutely fine to disagree with someone on a professional level. We programmers are an opinionated bunch, however there is no reason to be rude or arrogant... Especially when you are incorrect :)

One of the best attributes of the .NET community is the maturity level of the active participators. Sure, Rob Conery might have pissed a few people off, but at least his reaction was to the sheer immaturity of DHH and his Ruby crowd.

We are ASP.NET developers. Most of us are professionals, some of us are Gods. We are all above acting like children*.

If you break it all down, all web developers have a common interest. We just choose different routes to accomplish our goal. It is time to end the petty name calling and arguments between different camps.

Giles Bowkett gets it:

Don't program in Ruby because you want power or efficiency. Don't program in Ruby because you think you "should", either. Program in Ruby because you like it. And if you don't like it, don't program in it. Religious wars over programming languages are just silly. The messianic zeal of Christianity's shameful Crusades a thousand years ago still lingers on in Western culture, and one glaring example is the ludicrous idea that there should be one true language or one true editor, or one ring to rule them all. It's much better when programmers can work in multiple languages, multiple editors, and multiple environments. Diversity is healthy for ecologies. This is a point Neal makes in his podcast - he calls it polyglot programming, which is to say multilingual programming. He calls it a positive trend, and I agree.

I challenge all developers to blog on what they love, without trashing what they don't. Spend your time creating masterpieces in the technology you use. Together, we can create innovations that will change the internet.

* Yes, I am guilty of this too.

Keep Presentation and Logic Separate!

noreply@blogger.com (Jonathan Holland) — Fri, 23 Nov 2007 23:29:00 +0000

Update: One of my commenters dedicated an entire blog post on attacking this technique, prompting me to write this response.

ASP.NET somewhat emulates the MVC architecture with its code behind web forms. For those who are not familiar, each web form consists of two files; The ASPX file used for defining the appearance of the page (View), and a code behind file is used to implement the page logic (Controller).

For the most part, it is easy to keep a clean separation of concerns between the two files. However, I repeatedly see inline code mixed in with presentation when people are using data bound controls.

An example would be the ASP:Repeater control. In a nutshell, the repeater control allows you to create a template and populate it with data from any databindable source (Be it a DataSet, a DataReader, or even a custom collection).

A common implementation of the ASP:Repeater would be similar to this code from an early version of CodeBlog:

    1 <asp:Repeater ID="rptrComment" runat="server">
    2     <ItemTemplate>
    3         <div class="comment-body">
    4             <%# DataBinder.Eval(Container.DataItem, "CommentText") %>
    5             <div class="comment-name">
    6                 <a href="<%# DataBinder.Eval(Container.DataItem,"AuthorWeb") %>">
    7                     <%# DataBinder.Eval(Container.DataItem, "AuthorName") %>
    8                 </a>
    9                 - <%# DataBinder.Eval(Container.DataItem, "ShortDateTime") %>
   10             </div>
   11         </div>
   12     </ItemTemplate>
   13 </asp:Repeater>

This repeater was bound to the Comment custom collection I wrote from CodeBlog's business objects. While it works flawlessly, we are embedding inline code to loosely bind our collection to the fields we want outputted.

The ItemDataBound event is fired every time the repeater binds an item. By catching this event, we can move all of our code to the code behind file where it belongs. We can also add some logic (such as suppressing the hyper link if we don't have a website in the comment object).

    1 <asp:Repeater ID="rptrComment" runat="server">
    2     <ItemTemplate>
    3         <div class="comment-body">
    4             <asp:Literal ID="litCommentText" runat="server" />
    5             <div class="comment-name">
    6                 <asp:HyperLink id="hplCommentAuthor" runat="server">                       
    7                     <asp:Label ID="lblCommentAuthorName" runat="server" />                            
    8                 </asp:HyperLink>
    9                 - <asp:Label ID="lblCommentDateTime" runat="server" />
   10             </div>
   11         </div>
   12     </ItemTemplate>
   13 </asp:Repeater>
   14 

The main difference between the two code snippets is that the inline code has been replaced with ASP.NET Server controls. We will populate these controls on each ItemDataBound event. With the inline code gone, the Repeater is much more concise and this page will be easier to maintain in the future.

In the code behind file, the first task is to capture the ItemDataBound event for the repeater. This is done by overriding OnInit (if you haven't already for some other reason) and adding the event handler callback:

    1 protected override void OnInit(EventArgs e)
    2 {
    3     base.OnInit(e);
    4     rptrComment.ItemDataBound += new RepeaterItemEventHandler(rptrCommentsItemDataBound);
    5 }

With this done, we can implement a method to handle the event:

    1 private void rptrCommentsItemDataBound(Object Sender, RepeaterItemEventArgs e)
    2 {
    3     // This event will be fired even for Header, Seperator, and Footer rows, so we ignore those
    4     if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
    5     {
    6 
    7         // Item.DataItem contains the Item we are binding, in this case, the custom Business Object Comment
    8         // A simple cast is all that it takes to convert Item.DataItem into a Comment.
    9         Comment currentComment = (Comment) e.Item.DataItem;
   10 
   11         // We have to create references to the controls in the Repeater using FindControl
   12         Literal CommentText = (Literal)e.Item.FindControl("litCommentText");
   13         Label CommentAuthorName = (Label)e.Item.FindControl("lblCommentAuthorName");
   14         Label CommentDateTime = (Label)e.Item.FindControl("lblCommentDateTime");
   15         HyperLink CommentAuthor = (HyperLink)e.Item.FindControl("hplCommentAuthor");
   16 
   17         // Populate the Controls with Data from the Comment Object
   18         CommentText.Text = currentComment.Text;
   19         CommentAuthorName.Text = currentComment.AuthorName;
   20         CommentDateTime.Text = currentComment.ShortDateTime;
   21 
   22         // A little logic allows us to only populate the Hyperlink of we have a website stored.
   23         if (currentComment.AuthorWeb != string.Empty)
   24         {
   25             CommentAuthor.NavigateUrl = currentComment.AuthorWeb;
   26         }
   27     }
   28 }

The code comments explain the technique fairly well. To summorize, each time the event is fired, Item.DataItem returns a unique Comment object. At that point, it is a trivial matter of setting the Server controls properties with information obtained by the object.

By making these small changes, I have moved all of the logic into the code behind file where it belongs making ASPX file easier to follow. I was also able to add some conditional logic on the databinding, and the result was a very easy to understand event handler. Overall, this creates clean code that is easy to understand and even easier to maintain.

There is never a reason to use inline code when you are databinding. Keep a clean separation of concerns and keep your presentation layer and logic layer where they belong.

A Special Thanksgiving

noreply@blogger.com (Jonathan Holland) — Thu, 22 Nov 2007 19:01:00 +0000

I started this blog two weeks ago dedicated to writing a blog post a day. However, I was only able to keep up at that pace for one week. It was a productive week though, with almost 10,000 unique visitors, and a lot of healthy discussion.

Those of you who have subscribed may have wondered why I have not posted for the last few days.

On Sunday, my wife was induced into labor and we had our 2nd child, Connor, at 3:30 AM Monday morning after about 18 hours of labor.

So, as you can imagine, We have been rather busy :)

Happy Thanksgiving to all, and this blog will be back to its regular daily postings tomorrow.