source code bean

About a month ago I finished reading the book ASP.NET MVC 1.0 – Test Driven Development by Emad Ibrahim. The book weighs in only at about 300 pages, making it easily something you can read in a couple of nights. The book is written in tutorial fashion and is is probably best read with a laptop running Visual Studio on your lap, so you can follow the examples in the book. The paradigm of the book is Problem, Design, Solution. Emand gudies the reader though the full process of creating a web application in a Test Driven manner.

Besides from only presenting MVC and TTD Emand presents several very useful libraries for Test Driven Development:

• Moq – A mocking library for .NET that uses the power of LINQ to create mocks.
• Ninject – Dependency injection library for .NET
• MBunit – An alternative to VSTest

I think the book gives a good kickstart in ASP.NET MVC and TTD. My favorite part of the book was actually not reading about MVC itself, it was reading about testing it – Emad shows the strengths of MVC by showing how it makes testing easier.

I have been doing some research on NASes for home use. I basically want a NAS that offers redundancy (some form of raid), the ability to add disks as I go. It should also support at least SMB as file sharing protocol (but preferable others as well), and of course not be too expensive. All home NASes I have found yet has been lacking on at least one of the above criteria.

I have read about people using ZFS on FreeBSD or OpenSolaris for their storage servers. ZFS is a open source file system developed by Sun Microsystems which has some features that makes it very compelling for a file storage server. Unfourtanly ZFS is not available on Linux at the time of writing (i think it is some licensing issues that is preventing a port of it), if it were I would definitely go for it.

To give it a try, i downloaded OpenSolaris 2009.6 and installed it as a virtual machine in VMware Fusion. Instead of having to add several virtual disks to the VM, i decided to test the features of ZFS using regular files (ZFS can use files as disk devices). An easy way to create some “disks” is to use the mkfile command, it will create a file that can be used a disk device:

# mkfile 100m /tmp/disk1
# mkfile 100m /tmp/disk2
# mkfile 100m /tmp/disk3
# mkfile 100m /tmp/disk4

ZFS has tree leveles. The highest level is a ZFS pool, which can consist of several ZFS filesystems. A ZFS filesystem consists of one or more devices. Filesystems within a pool share its resources and are not restricted to a fixed size. You can add or remove devices to a pool (for example to increase your storage space), while the pool is running. Devices in a filesystem can be configured in mirrored mode or in RAIDZ mode to offer redundancy. ZFS also supports filesystem level snapshots and cloning from existing file systems. The two main ZFS commands are:

zpool - Manages the pools and the devices within them
zfs - Manages ZFS filesystems

Ok, so lets create a pool from the disks we created earlier:

# zpool create storage /tmp/disk1 /tmp/disk2

# zpool list
NAME SIZE USED AVAIL CAP HEALTH ALTROOT
rpool 7.94G 4.28G 3.66G 53% ONLINE -
storage 191M 74.5K 191M 0% ONLINE -

As you can see we combined two disks into one pool. The filesystem automatically gets mounted on /storage (this is the default mount point, it can be changed). No volume management, configuration or formatting is needed. Lets destoy this pool to create a more interesting one.

# zpool destroy storage

# zpool list
NAME SIZE USED AVAIL CAP HEALTH ALTROOT
rpool 7.94G 4.36G 3.58G 54% ONLINE -

As you can see, it is gone. Lets create a new pool using RAIDZ (a form of raid, similar to RAID5):

# zpool create storage raidz /tmp/disk1 /tmp/disk2 /tmp/disk3

# zpool list
NAME SIZE USED AVAIL CAP HEALTH ALTROOT
rpool 7.94G 4.38G 3.56G 55% ONLINE -
storage 286M 140K 286M 0% ONLINE -


One thing that’s a little different in a ZFS raidz pool versus other RAID-5 filesystems is that the reported available disk space doesn’t subtract the space required by parity. Of course parity will take up space, so this is something to keep in mind when monitoring the disks. We can monitor the status of the pool by using the zpool status command:

# zpool status storage
pool: storage
state: ONLINE
scrub: none requested
config:

NAME STATE READ WRITE CKSUM
storage ONLINE 0 0 0
raidz1 ONLINE 0 0 0
/tmp/disk1 ONLINE 0 0 0
/tmp/disk2 ONLINE 0 0 0
/tmp/disk3 ONLINE 0 0 0

errors: No known data errors

After some playing around with ZFS i certainly think it would be a great choice for a storage server. It is way easier to use than the software/LVM solutions i have tried on Linux. The biggest drawback would be OpenSolaris itself, I just find the GNU application userland easier to use compared to the Solaris one. Maybe I should give Nexenta (OpenSolaris Kernel, GNU application userland) a chance?

Read more:
ZFS on Wikipedia
RAID-Z

So I restored a backup from from MSSQL 2005 to a MSSQL 2008 database, which kept the database in “SQL 2005 compatibly mode”. I thought that this would mean that the database could actually be backed up from the MSSQL 2008 server to the MSSQL 2005 server, however it turns out that this is not the case. Backing it up from 2008 and trying to restore it, resulted in the the following slightly cryptic error:

An exception occurred while executing a Transact-SQL statement or batch. (Microsoft.SqlServer.Express.ConnectionInfo)
The media family on device ‘C:\Temp\db.bak’ is incorrectly formed. SQL Server cannot process this media family.
RESTORE HEADERONLY is terminating abnormally. (Microsoft SQL Server, Error: 3241)

After some googeling it turns out that MSSQL 2005 can not read backups from 2008. The solution I found to the problem was to export the database as a SQL script, and running the script on the SQL 2005 server. Maybe not the best solution, but it saved my day.

This is how you create the script file:
In Object Explorer in SQL 2008 management studio, right-click the database, select Tasks->Generate Scripts. In the options dialog enable everything, including Script Data. Make sure you select “Script for SQL 2005″ (otherwise you will export a SQL 2008 script file). Then run the script on your SQL 2005 server and hopefully you are done!

While reading the EPiServer 5 SDK documentation, i found this:

Rename a Folder

There is no Rename method on the EPiServer.Web.Hosting.UnifiedDirectory class. To rename a folder you need to call the MoveTo method as follows:

1.  
2. protected void RenameFolder(string path, string oldName, string name)
3. {
4.     if (IsFolder(path))
5.     {
6.         UnifiedDirectory directory =
7.         System.Web.Hosting.HostingEnvironment.VirtualPathProvider.GetDirectory(path) as UnifiedDirectory;
8.  
9.         int e = -1;
10.         while (path.IndexOf(oldName, ++e) > -1) ;
11.  
12.         StringBuilder sb = new StringBuilder();
13.         sb.Append(path.Substring(0, e – 1));
14.         sb.Append(name);
15.         sb.Append("/");
16.  
17.         directory.MoveTo(sb.ToString());
18.     }
19. }
20.  

What a convenient way of renaming a folder Good thing that you don’t have to do it too often.

I recently needed to setup a new ASP.NET development environment and deiced to give Microsofts Web Platform Installer 2.0 a chance. I had actually never heard about this product before, but what it does is installing .NET, the needed development libraries, and the express versions of Visual Studio and SQL Server. It required three reboots, but in total it saved me a lot of time!

For the last month I have been playing around with WSGI in Python. WSGI is an interface between the web server and the web application, it is meant to simplify writing your own web framework in Python. My intention is not to write an fully fledged web framework, but rather just play around with some ideas I have and try it out.

In WSGI an application is just a callable object (remember that in Python functions are objects too!) that takes two parameters, environ and start_response. A very simple application could look like this:

Not very exiting but it shows us the very basics of WSGI. The function start_response is a function that, as the name implies, starts sending out the response. This is where you give status and headers. Lastly the application returns an iterator with the body response (usually a list of strings or a list containing one string that is the entire body). As you can see WSGI lets code pass around web request in a fairly formal way.

To run this application you can either install Apache and configure it with modwsgi, this might however be slightly overkill just in order to test the application. Instead I recommend installing Python Paste (pythonpaste.com), which is kind of a framework for web frameworks. It includes a lot of functionality that can be reused, but more importantly right now, it includes a simple web server that can serve WSGI applications. In Ubuntu 9.04 (the operating system I am currently running) Paste can be installed using apt:

To run the application, add the folowing lines to the end of your source file:

Now it should be possible to run the application:

Your web application is now up running! In the next part i will introduce you to a slightly more exiting application.

I was having a chat the other day with Danish Peter (yes, another one) about URL rewrites in ASP.NET. In a previous post I wrote about how to use friendly URLs in the Zend framework, in this post, which is based on our discussion, I will discuss how to do this in ASP.NET.

Friendly URLs are achieved by a technique called URL-rewrite. A friendly URL is a URL that is easy to read and understand. Let me give you an example (from a site my girlfriend loves) of what is NOT a friendly URL:

http://www.bebe.com/bebe-Jersey-Knit-Apron-Dress/dp/B001UX1NBQ?ie=UTF8&asinSearchPageIndex=13&pf_rd_r=1C6TS27BZZ1CAD6WY81S&navAsinList=B001UNM3XS%2CB001OPYKKQ%2CB001UNNQ52%2CB001RPD88I%
2CB001R4NHHQ%2CB0026BM39W%2CB001QOU6TY%2CB001UX1NNY%2CB001UAA4WI
%2CB0024QP6KM%2CB0026RRN4G%2CB0027DCI6W%2CB001UX3QL6%2CB001UX1NBQ
%2CB001VROPT8%2CB00265NBKS%2CB001RPM80C%2CB001UBWNTO%2CB001RPIC1G
%2CB001PA2NMW&node=675941011&pf_rd_s=search-results&field_browse=675941011&searchSize=20&navAsinListIndex=0&pf_rd_t=101&field_availability=0&id=bebe%20Jersey%20Knit%20Apron%20Dress&searchBinNameList=null&store=core&pf_rd_p=476815091&ref=search_results_14&searchNodeID=675941011&pf_rd_i=675941011&field_launch-date=-1y&searchRank=-custom-rank&searchPage=1&pf_rd_m=A2FMOXN01TSNYY

This might be an extreme example, but there are plenty of sites which are as bad. If the above URL was transformed into a friendly URL it might look something like:

http://www.bebe.com/Apparel/Dresses/Jersey-Knit-Apron-Dress.html

The second address is easier to read. URL rewrite techniques have been around for a long time and the first time I used it was back in the early Apache 1.3 days. Today good sites use friendly URLs and if you have not adopted it yet, you need to start using it.

There are several benefits from using a friendly url scheme, the most prominent are:

1. 1. The clear structure makes it easier for humans to read and understand the addres
2. 2. It is easier for search engines to understand what the address is and crawler the site. URL structure that goes more than three directories deep is not always read by a spider.
3. 3. If search engines understand the URL, it is also easier for them to help people finding what they want, giving better search results. Hence using keywords and proper titles makes life easier.

What options are there for ASP.NET?
There is no built in support for having friendly URLs in ASP.NET, but you could spend your time writing your own URL-rewrite module. Writing your own module is basically spending time reinventing the wheel. If you have the time, go ahead, but if not there are already several good ones out there (free and open source). One that I have found very useful is the URLRewriter.NET (http://urlrewriter.net/). URLRewriter.NET provides similar rewrite capabilities as the mod_rewrite does for Apache.

Using URLRewriter.NET
It is possible to use the URLRewriter.NET module without making any changes to the IIS configuration, this will however limit the functionallity the URLRewriter.NET rewriting capabilities. To use its full power, IIS should be configured to map all requests to the ASP.NET runtime (how to do this is covered in the manual). We will only be touching the surface of URLRewriter.NET so we will not have to do any modifications to the IIS configuration.

To add URLRewriter.NET to your project start out by opening Visual Studio or Visual Web Developer. Open your project and then right click the project in the solution explorer and click on Add Reference, go browse and find the folder you downloaded and unzipped. You will find the binary (.dll) file in “Loation”\urlrewriternet20rc1b6\UrlRewriterV2\bin\Release.

Before we can use the module we need to make some changes to the web.config. Add the following in the configSections:

This will allow the URL writer to read the rewrite rules we will define later. Now we need to add this module to the httpModules section:

By adding the rewriter as a httpModule we allow it to intercept web requests and route the requests to the actual aspx file serving the page. Now we need to define the rewrite rules:

The rewrite rules are defined using regular expressions. Regular expressions are very powerful and is something every programmer should know. The syntax might be hard to remember but there are several great tools to help build advanced regular expressions, for example the RegexDesigner.NET (http://www.sellsbrothers.com/tools/#regexd) that Chris Sells has created.

The above rewrite rules are simple. The first rewrite rule will rewrite URLs like

sourcecodebean.com/2009/04/01/1.shtml

to

sourcecodebean.com/Default.aspx?Year=2009&Month=04&Date=01&Id=1

And the second rewrite rule will match requests starting with ~/Article/ so it will rewrite URLs like

sourcecodebean.com/Article/1.shtml

to

sourcecodebean.com/Articles.aspx?ID=1

Finishing up
By now you hopefully have a functioning site that uses friendly URLs. One of the common problems you might run into is broken links. To avoid this you should make sure that you reference all your pages from the root level (~) and that all your links has the runat=server tag.

Thanks for your input Peter! You can check out his Danish Peter blog over at Magic Mouse.

For the last three months I have been working with one of Sweden’s largest companies. When I arrived the first day I noticed that it was not possible to log in to the intranet using Firefox. The explanation I received:

“our sites are built for Internet Explorer, you have to use it”

In my head a warning bell rang. I fired up Internet Explorer to find that the whole site was a horrible mix of broken HTML, badly written Javascript, lot of frames and almost no use of CSS. It surly could not work in anything else other than Internet Explorer 6 and 7.

My job was not the development of the intranet (which I am glad for), so I just told the customer what I thought and that they should do a better job of following web standards so the users could use the browser of their choice. The kind of stupid response I got was something in style with:

“we concentrate on Microsoft technologies, so the only requirement we have is that it should work in Internet Explorer”

The fun started during my last week at the company, when Microsoft started to push out Internet Explorer 8 to all Windows Update users. IE8 is actually very strict when it comes to following web standards. Lo and behold, none of the users who had their systems upgraded could use the intranet. IE8, now strict on standards, vomited back the bad intranet and the company basically came to standstill. Chaos!

I observed the chaos (smiling) for an hour before I decided to save the day by telling them about “EmulateIE7″. By default, IE8 uses the new IE8 rendering engine. The big difference from before is that if a site is broken IE8 will NOT default to an older rendering engine. This is different from how older IE browsers behaved and is clearly a step in the right direction for Microsoft to support web standards. However they have not scraped backwards compatibility entirely. In order to allow for broken sites to be viewed in IE8, it is possible for the developer to add the following meta-tag to the page:

This tag will tell IE8 to use the IE7 rendering engine.

And if you are stubborn enough to believe that building websites for browsers is acceptable, there are reasons why we need web standards:

1. 1. Accessibility is the law: FCC regulations in the United States require that web sites are accessible to people with disabilities. If a website cannot be viewed by someone with an impairment, it is not only illegal but highly unfair to visitors. With proper web standards, these visitors can change font and modify a website layout to make it easier to read.
2. 2. Better search engine rankings: While people may be gung ho for “SEO” and those techniques, some of the most basic and most important ways of reading a website can improve the reading by a search engine spider. Combined with semantic markup, the separation of content and presentation generally improves search engine rankings.
3. 3. Easier development and maintenance: Using semantic and structured HTML makes it easier and quicker to understand code created by somebody else. Since every programmer leaves a footprint in their style of code, those that write web standards will make it easy for others to understand code. It will also help avoid the hackneyed job that many sites exist in today.
4. 4. CSS = Faster downloading and rendering of pages: Using CSS for presentation style leads to leaner HTML documents. It also makes it easier to globally change attributes. Leaner files means quicker downloads for visitors.
5. 5. Semantic HTML is friendly to adaptation: Semantically marked up documents can beadapted to print and alternative browsing devices (PDAs, iPhones, netbooks) by linking to a different CSS file.

After the incident was resolved we had a long discussing about web standards, and the company now understands that you can not design a site for a certain browser, it should be designed to follow accepted web standards.

I first learned about functional programming a few years ago when I took a class in Haskell programming at my university, Chalmers. While Haskell might not be for everyday use, many of the concepts are very compelling, such as higher order functions, pattern matching, lazy evaluation, list comprehensions, lambda functions and map/fold/filter. Over the years many mainstream programming languages have adopted a subset of those features. With the release of C# 3.0 Microsoft has brought some of this functionality to C#.

Lambda functions
A lambda function is simply an anonymous function that can contain expressions and statements. Lambda functions can be used to create delegates or expression trees. Lambda functions use the lambda operator => (read as “goes to”). On the left side the input parameters is defined and the right side holds the expressions or statements. A simple example would be:

But wait, where is the type declaration? The types does not have to be defined, the compiler will declare the types by using type interference at compile time, so everything is still strongly typed.

The framework defines a number of parameterized delegate types (the first type is the return type):

So we could define our function as follows:

Map/fold/filter
In functional programming it is very common to work with lists. Three very common computations are:

1. Applying a function to every element of a list (map)

2. Computing a value based on all elements in the list. For example the total sum of a list containing numeric values (fold)

3. Selecting just a subset of the elements (filter)

In C# the equivalents are Select, Aggregate and Where. Here is a simple example of how they can be used:

Using map/fold/filter instead of using regular loops makes it easier to understand and reason your code.

You would think that ASP.NET would have build in support for something so simple as clearing all input fields on a page, but no. However, this easy to add. Add the following to your Page_Load (btnClear should be the name of your clear button):


btnClear.Attributes.Add("onClick", "document.forms[0].reset();return false;");