The janitor's closet

Automated Builds and Continuous Integration with Jenkins

noreply@blogger.com (Bob The Janitor (Richard)) — Thu, 19 Jan 2012 19:50:00 +0000

The concept of an automated build is fairly basic, you simply take your existing build file (make, nant, ant, msbuild(.sln), rake) and set up a service to build it from your source control repository.

Automating builds

Setting up automated builds provide a number of advantages:

Everything your project needs to build and run is checked into source control.
By scripting your builds you remove human error problems, computers are just better at running repetitive tasks
Logging what was done and when it was done.

At a former employer the marketing department needed to do content updates on a fairy regular basis; So they wouldn’t have to wait for us, I set them up with svn for the content directory and created some users for content deployment. All they had to do was update the content and commit it and then deploy it. We where happy because we didn’t need to spend time on their deployments, and they where happy because they could push content any time they wanted to.

Continuous Integration

This is a key part of doing Test Driven Development, making sure your tests are run when checked in. This makes sure that all of the tests are working in the build environment, and lets everyone know when there is a problem as soon as the build runs, and lets the developer responsible to fix it as soon as possible, creating an over all better code quality.

Using Jenkins

Jenkins is an open source Build server forked from the Hudson project, basically when Oracle bought Sun/Java some of the Hudson team decided to was time to go their own way. Jenkins Benefits from a log history of community support from it’s Hudson days allowing it to be a very mature and extendable system. Having said that, it not as easy to use as some other build servers (see Continues Integration with TeamCity) but what it lacks in ease of use, it makes up for in versatility and flexibility.

User Management

Like most things in Jenkins User management is very flexible by default supporting LDAP, it’s own internal user DB, delegate to servlet container, and has a huge list of user management plug-ins for everything from Active Directory to GitHub OAuth. Once the user is added you also have a fairly flexible authorization set up from allowing anyone to do anything to completely locking it down.

My biggest complaint here is that by default everything is wide open and the responsibility of locking everything down is placed on the administrator.

Build Jobs

By default Jenkins supports Maven2/3, completely rolling your own multi part build, and Monitoring an external job but with a large selection of plug-ins supporting everything from rake to powershell to Fitness, to an Android Emulator.

Rolling your own multi part build is fairly strait forward if a little involved with a lot of the basic options you would expect like wither to keep old builds, how long do you want to keep them, how many do you keep, Quiet period, retry count, etc.

With it’s plug-ins your source control provider options are just about anything you can think of including:SVN, CSV, Git, ClearCase, etc. The same for build triggers by default it supports build after other projects, build periodically(nightly builds for example), pull scm, and remote triggering(call a url with an auth token to start a build).

When your done with your build you have built in support to ftp or ssh your build results with plug-ins to do everything from upload to Amazon S3 to the Appaloose Store for mobile apps.

The down side to all of this flexibility is you are forced to do a lot for the configuration your self, unlike TeamCity, if you want your code test results published you have to configure it yourself, if you want your code coverage results, you have to configure it to use something like PartCover yourself.

Reporting

Just as important as automating your builds is knowing what is going on with them, when are they running, did it fail, what failed, etc. Jenkins has fairly nice tools built in to show you what is going on. With a build history trend report, rss feeds, Email notification, and plug-ins to support everything from dashboard views to creating a Wall friendly display of all build jobs.

Conclusion

While not as nice to set up and manage as some other build servers, Jenkins is incredibly powerful with a lot of flexibly, and to be honest it’s really hard to complain about an enterprise level build server for free. I would make the comparison between running Linux VS. Windows servers, Windows may be more polished but it’s not as flexible.

Finally decided to do a dev tools list

noreply@blogger.com (Bob The Janitor (Richard)) — Mon, 09 Jan 2012 05:28:00 +0000

One of the most important parts of being a craftsman is your selection of tools, it doesn’t matter if you are a carpenter, a mason, cabinet maker, or even a software developer, your tools allow you to get the work done. What tools you use really depends on your style and technique and may very greatly depending on the person. This is a simple list of IDEs, editors, libraries, etc. that I like and work for me, some are pay for, most are not. This isn't a complete list of the tools I use but it's a good solid overview of what I use on a day to day basis, take a look and see what you like, or don’t.

IDEs

Visual Studio 2010 – The default editor for doing .NET development, it has it’s share of problems but for the most part it a very sold IDE.
MonoDevelop – This is where .NET started for me 8 years ago, not a lot of frills, but for a fully functional cross platform IDE for .NET the price is right at free, unless you want to do Android or IOS, then you need to buy monoDroid or monoTouch.
NetBeans – My go to java and PHP IDE, with good intellisense and built in refactoring tools.

Visual Studio Plugins

Resharper – The most valuable IDE plugin I have ever used, providing nUnit support, refactoring, add reference, and the list keeps going. I honestly have a hard time using Visual Studio with out it.
DotCover – An important part of test driven development is code coverage, and DotCover is my coverage tool of choice. It integrates with Resharper’s test runner to provide on request code coverage in the IDE.

Source Control

AnkhSVN – Provides SVN support for Visual Studio, so far this is the best free SVN plugin I have found for Visual Studio
Visual SVN server – A simple and easy SVN server that just works, it may not have a lot of bells and whistles but it’s easy to install and manage users.

Text Editors

Notepad++ – One of the first things I do on any new windows system is install Notepad++, it integrates with Windows explorer making it simple to edit any text file with out having to deal with what the default app is for the ext. with a huge list of plugins for everything from XML to powershell it is the Swiss Army Knife of text editors.

SQL Tools

Toad For SQL Server – This is a new item on my tools list, I just started using it this week, but I really like it. The community version has some really nice intellisense, and the way the UI works is just clean. I’m really interested in seeing a head to head comparison between Redgate’s SQL Tool belt and Toad Development Suite for SqlServer, the features look about the same, but at around $1,300 vs. $2,000 toad is a lot cheaper.
FluentMigriator – A .NET version of the Ruby Migrations tool. With a fairly simple syntax and helpers it makes scripting DB changes easy, to read more check out this blog post I did a little while ago, Using Fluentmigrator with nant.

Unit Testing

NUnit – The work horse of the .NET unit testing world. It’s a solid testing framework with some of the best tool support out there, with the exception if Visual Studio, but Resharper fixes that.
Moq – The Simplest mocking framework for .NET. With a clean fluent syntax that provides ease of use and versatility.

Build And CI Server

Team City – By far the easiest to get set up and start running with. With built in support for most of the tools I use and has DotCover built in, it provides a solid solution out of the box with a very polished UX.
Jenkins – A fork of the Hudson project, Jenkins is a solid if less then polished build and CI server solution, but what it lacks in polish it makes up in versatility and flexibility, with a huge selection of plugins for integrating into just about development environment and deploying to just about any other system out there.

Test Driven Development for the management point of view

noreply@blogger.com (Bob The Janitor (Richard)) — Thu, 05 Jan 2012 21:09:00 +0000

When I have given presentations on TDD, one of the biggest questions I get is “How do I sell this to my boss?”, and it’s a very valid question, you are basically asking your boss to let you write 2-3x as much code to make sure the code you wrote is correct, that’s a tough sell all on its own. Software can never be done soon enough, most projects are already behind from the start, and now you want to take more time to write more code?

Time is Money

There is a cost to Test Driven Development (TDD), you are doing more work, writing tests takes time, maintaining tests takes time, and running tests takes time. With time equaling money the question is “what are you buying?”, the simple answer is security, and long term cost reducion.

Ever wonder what it would be like to have a car without a check engine light? For the most part it’s something most of us never look at. When it turns on we take it to the shop and the mechanic fixes whatever is wrong. Without the check engine light to tell you something is wrong, what could have been a small repair is now an engine rebuild. Having test provides you with the same thing, it lets you know there is a problem before it becomes a larger problem, this could be inconsistent application behavior, data corruption, or the application crashing.

Real world example

At a former employer we were migrating to a new production database for our flagship application, the database it’s self was a very complex system, lots of tables, triggers, stored procedures, etc. The DBA migrated the schema to the new server, got a snapshot of the data and then ran our integration tests and had failures everywhere, invalid permissions, missing columns, etc. Even using the failed tests as a road map to took the DBAs 1 ½ days to fix all of the problems. I can’t even guess how long it would have taken to fix if we would have just done to production, on top of that the company’s main product would have been down, not only affecting us, but also all of our customers that depended on our product to run their businesses.

We Could have just blamed the DBA for not getting everything right the first time, but at the same time, how much time was he given to do it, would it have been cost effective to spend more time for this one time, verses spending the time writing tests that can test it over and over again.

Spending a little to save a lot

Software bugs have costs: they cost to find, they cost to track, they cost to fix, they cost to verify when fixed, and they cost to push out the fix.

Cheap - A developer finds a bug when it was written, he/she fixes it, very little cost
More Expensive - QA finds the bug, the tester needs to make sure it’s an actual bug, retest to verify how to reproduce it, then records it a bug report, sends the bug report to the developer, the developer fixes the bug, send the fix back to QA, it’s retested, then the bug report is closed.
Very Expensive – User finds bug, contacts customer service, customer service sends bug to QA, QA verifies the bug, creates a bug report, developer fixes bug, sends the fix to QA, QA verify bug is fixed, bug fix is redeployed to production.

How much the bug costs depends on how soon it’s discovered, the sooner it’s discovered, the less people touch it and the less it costs. By writing tests developers are far more likely to find bugs sooner also nothing is more frustrating than having bugs reappear, manually retesting existing functionality takes time, and increases QA cost, also reduces the time QA has to find new bugs, and edge case bugs. TDD inherently provides regression testing and can greatly reduce your QA time.

Real world example

At one time I worked as a QA Engineer at a major printer company, a little over half my time was spent not only testing new functionality, but existing functionality as well, the rest of my time was spent sending bug reports to the developers, having the developers asking for clarification, verifying the bug was fixed, etc. As much as it cost for me to test a printer, the cost of having a driver or even worse a firmware bug get released to the customer where astronomical. By reducing the time I had to spend retesting and verifying bugs, I could spend more time looking for edge case bugs.

Something else to think about it unlike web development where you are only pushing code to your servers, having hardware in the hands of consumers with a bug requires the add cost of service representatives, service techs, etc.

Reducing Costs by building on a well build foundation

TDD by it nature encourages good development practices, by breaking up chunks of code into more testable sections, you are turning them into more manageable pieces; this reduces the amount of time and effort required to update and maintain your application and greatly reducing the need for the dreaded rewrite.

Ask any construction contractor what makes the biggest difference on a building remodel, and they are probably going to tell you “How well the original building was built”. If the foundation isn’t level or the walls aren’t straight, it’s going to make his job that much harder having to compensate for the existing structure. The same thing applies to software development, the less old code that needs to change to add new features, the less it costs to add new feature with the added bonus of the tests telling you where your changes affect the rest of the application.

Real world example

I worked on a project that was needed to replace how users authenticated; the user still entered a user name and password, but how they were verified need to be updated for security reasons. By having the application broken up, all that needed to be changed is adding the new authentication code and changing one line in the existing code to implement the new functionality.

Using TDD isn't required to use these best practices, but trying to do TDD without using them is painful to next to impossible.

More Ajax with MVC – Using Partial Views with Ajax

noreply@blogger.com (Bob The Janitor (Richard)) — Sun, 27 Nov 2011 10:55:00 +0000

One the the really nice features in asp.net mvc is the ability to use partial views, not only for breaking up pages and reusing content but also for doing Ajax calls. In Easy Ajax with ASP.NET MVC and jQuery I showed you how to do a basic Ajax call and display the data returned, now I’m going to show you something a little more useful, actually retuning content to display on the page.
First we take this partial view

@using SampleApplication.Models
@model PartialModel
  
<div>
    @Model.Text
</div>
<input type="button" value="click me" onclick="UpdateView();return false;"/>

Then we add it to the main view like this

<div id="UpdateableContent">
    @{ Html.RenderPartial("Partial",new PartialModel{Text = "Before Clicked"}); }
</div>

Next we need to have a Action to call that returns the rendered view with updates

public ActionResult UpdatePartial()
{
    var model = new PartialModel() {Text = "was updated"};
    return View("Partial", model);
}

In this case we update the model and return the specified partial view with the updated model.

Last we have the Javascript that makes the Ajax call

   1: function UpdateView() {

   2:     var model = { };

   3:     $.post("/home/UpdatePartial",

   4:         model,

   5:         function (data) {

   6:             $("#UpdateableContent").html(data);

   7:         });

   8: }

it’s fairly simple and a lot like what we did in the Easy Ajax post, the major difference is we take the returned rendered partial view and replace the existing rendering of the partial view using JQuery’s .html(), this replaces the existing content with the passed in content. This is a very simple and effective way to manipulate your pages.

As always here is the source code for a sample project using it

Using FluentMigrator with nAnt

noreply@blogger.com (Bob The Janitor (Richard)) — Sun, 17 Jul 2011 05:38:00 +0000

On a project I was working on a while ago, we all had local copies of the DB in versioned .sql files, and then every time we did an update we would run the sql in the DB files and hope it build the DB.
More often then not it would blow up and so I would spend the first 1/2 hour every time I worked on the project getting things to work again. Well no more!
FluentMigrator is based on Ruby Migrations, with a fairly simple syntax. The db classes have the attribute [Migration()] that specifies the version, and inherit from the Migration class, and override the two methods Up and Down.

   1: [Migration(20110624232410)]   2: public class AddUserTables : Migration   3: {   4:     public override void Up()   5:     {   6:         Create.Table("Users")   7:             .WithColumn("Id").AsInt32().Identity().NotNullable()   8:             .WithColumn("Name").AsString().NotNullable()   9:             .WithColumn("Password").AsAnsiString().NotNullable();  10:     }  11:    12:     public override void Down()  13:     {  14:         Delete.Table("Users");  15:     }  16: }

Migrating Up and Down

The Reason for the Up and Down methods is very simple; if the version your migrating to is higher then the version of this class it executes the code in the Up method and if the version is lower then the code in the Down method executes. Basically whatever you do in the Up is undone in the Down.

Setting The Version Number

Something else you may have noticed is in the Migration tag the version number is fairly large, to make versioning easier on a team, I’m not using consecutive numbers but the date and time(using 24 hour time) of when the I added this class, so the the example class I created was on 6/24/2011 at 23:24 10. The current version number is also stored in the DB, making it very simple to see what DB version you’re on, this can come in handy if your code is based on a specific DB version you can do a simple check to see if you have the correct DB version.

Keeping version iterations small

Just like when creating a business logic class, you should follow the single responsibility principal, and have each class do only one thing, this may mean having a lot of classes but on the other side it will make it a lot easier to keep track of what each version added, modified, or removed.

Adding stuff to the Data Base

Using the Fluent api allows you to very smoothly add tables, columns etc. in a very readable way. If you look at the Up method in the above example you can see how easy it is to add a table with columns. This makes it very easy to add your own extension methods to short had it even further. Here is an example for creating an identity column and a table with time stamps:

   1: internal static class MigrationExtensions   2: {   3:     public static ICreateTableColumnOptionOrWithColumnSyntax WithIdColumn(this ICreateTableWithColumnSyntax tableWithColumnSyntax)   4:     {   5:         return tableWithColumnSyntax   6:             .WithColumn("Id")   7:             .AsInt32()   8:             .NotNullable()   9:             .PrimaryKey()  10:             .Identity();  11:     }  12:    13:     public static ICreateTableColumnOptionOrWithColumnSyntax WithTimeStamps(this ICreateTableWithColumnSyntax tableWithColumnSyntax)  14:     {  15:         return tableWithColumnSyntax  16:             .WithColumn("CreatedAt").AsDateTime().NotNullable()  17:             .WithColumn("ModifiedAt").AsDateTime().NotNullable();  18:     }  19: }

But the api doesn't have everything you need so you have the option of adding in strait sql using Execute.Sql(). like this example:

   1: Execute.Sql("DELETE FROM `Users` WHERE Name = 'TestUser'");

also you can call sql files like this:

   1: Execute.Script("myscript.sql");

Adding Data

The next step is to add some data. This could be some sample data for development, a larger dataset for QA, QA data for a specific type of customer, or base data for production. By adding profiles you can abstract away what data you want to add for specific function. This is not where you add data for things the should be constant, things like lookup tables should be handled by a versioned migration class. Here is an example of a profile class:

   1: [Profile("Development")]   2: public class DevelopmentProfile : Migration   3: {   4:     public override void Up()   5:     {   6:                7:         Insert.IntoTable("Users").Row(new {Name = "TestUser", Password="12345"});   8:     }   9:    10:     public override void Down()  11:     {  12:         Execute.Sql("DELETE FROM `Users` WHERE Name = 'TestUser'");  13:     }  14: }

Just like a Version class it inherits from the Migration class and has an up and a down method, this way when you add one profile it will remove the other profiles.

Deploying/Migrating Your Data Base

Deploying or Migrating your data can be done with a console app or with a build runner like MSBuild, nAnt, or Rake making it easy to integrate into your existing build process. For this example we are going to use nAnt. Here is an example nAnt build file:

   1: xml version="1.0" encoding="UTF-8" ?>   2: <project name="FluentMigratorProof" xmlns="http://nant.sourceforge.net/release/0.90/nant.xsd" default="migrate-Production">   3:   <loadtasks assembly="./FluentMigrator.NAnt.dll" />   4:   <target name="Reset" description="Migrate the database to the base version">   5:     <migrate   6:     database="sql"   7:     connection="Data Source=DevBOX\SQLEXPRESS;Initial Catalog=FluentMigratorProof;User Id=BuildUser;Password=xxxxxxx;"   8:     namespace="FluentMigratorProof"   9:     target="./FluentMigratorProof.dll"  10:     task="rollback:all"  11:     />  12:   target>  13:   <target name="migrate-Production" description="Migrate the database to the latest version">  14:     <migrate  15:     database="sql"  16:     connection="Data Source=Production\SQLEXPRESS;Initial Catalog=FluentMigratorProof;User Id=BuildUser;Password=xxxxxxx;"  17:     namespace="FluentMigratorProof"  18:     target="./FluentMigratorProof.dll"  19:     profile="Production"  20:     />  21:   target>  22:   <target name="migrate-Development" description="Migrate the database to the latest version">  23:     <migrate  24:     database="sql"  25:     connection="Data Source=DevBOX\SQLEXPRESS;Initial Catalog=FluentMigratorProof;User Id=BuildUser;Password=xxxxxx;"  26:     namespace="FluentMigratorProof"  27:     target="./FluentMigratorProof"  28:     profile="Development"  29:     />  30:   target>  31: project>

To use FluentMigrator with nAnt you use loadtask to specify the FluentMigrator.dll then you add a migrate task in your target. Your migrate task will need to have the following properties:

database – this specifies the type of DB (sql, oracle, sqllight, mysql, etc.)
connection – this specifies the DataBase your going to connect to and with what permissions
namespace – this is the application namespace your going to run allowing you to migrate multiple DB in the same project
target – this is the .Dll you’re calling to migrate from
Profile – this is what profile your loading
task(optional) – this is how you specify what version you want to build, or if you want to roll back, etc.

Then to run your migration simply run NAnt.exe with the name of your build file something like:

   1: NAnt.exe -buildfile:ProofBuild.nant.build

A full explanation of using nAnt is a little out of scope for this blog post so if you want more info on nAnt see nAnt Help Page.

As always here is a sample project using this.

Where is the passion?

noreply@blogger.com (Bob The Janitor (Richard)) — Thu, 14 Jul 2011 06:03:00 +0000

On the 4th of July I had a really good conversation with @jamis a former member of the rails core team and a fairly prominent member of the ruby community and I was reminded how much the Ruby community appers to be more dedicated to craftmanship then the .net community as a whole.

This may be just an outsiders view but ruby devs seem to be more dedicated to pair programing, TDD, CI, etc. and basicly more interested in writing software to make a living vs. where in the dot net comunity it feels more like developers write software just to make a living, there are a few leaders that that push these ideas, but for the most part it seem more previlant in the ruby community.

So my real question is, why? is the ruby stack just more attractive to people of this disposion? is it just becouse dot net is just more widely used and thus just has a wider spectrum of developers in it? Is it just becouse I have a very limmited view of the ruby community and only seeing the cream of the crop, or am I just somewhat jaded and only seeing the negative in the .net community? To this I don't have a good answer.

So the next question is how do we get the passion in the .NET dev stack? it's not like there is a lack of interesting things to learn and build, can we do more community work? Boise has a .NET user group (netdug), a software developers group(bsdg) that is mostly .net developers, and a code camp every year, but for the most part it's the same people group presenting. my open question to the group is how do we get more people interested in presenting, do we start younger? maybe start youth dev groups? maybe as a group pressure each other to be more active? For my part, I need to step up and do my part, and rededicate myself to blogging.

Decoupling to Destruction

noreply@blogger.com (Bob The Janitor (Richard)) — Mon, 23 May 2011 14:02:00 +0000

One of the core concepts of well architected code is being decoupled, but like so many of the good things in life if you do it to much it becomes bad for you.

Recently I worked on a piece if legacy code that from the UI to the Dal it passed an object though 7 classes and was converted from one object to the next 5 times. Their wasn’t any real difference from one object to the next. In some cases it was pulled from the data object and each item was passed as a parameter into a method where it was then put into a new object. The result was next to imposable to debug, even harder to read, and in a lot of places just plain sloppy.

In an earlier post N-Tier Design Revisit part 2 – Data Entities I talked about how data entities, poco, or dto (they are all basically the same thing more or less) work, they go from the UI though the Biz and to the Dal and back again. This creates a message that is passed, your code is still decoupled because the Data Entity basally contains no logic, it’s just holding data.

Wring an application is kind of like growing a garden, if you take care of it and maintain it, it stays nice and easy to maintain. If you neglect it it becomes difficult to maintain and will over time die. Decoupling is one of the things you do to make it easy to maintain your application, kind of like watering it, and just like watering it if you do it to much you’ll kill it.

Easy Ajax with ASP.NET MVC and Jquery

noreply@blogger.com (Bob The Janitor (Richard)) — Thu, 02 Dec 2010 08:26:00 +0000

One of the reasons I love Asp.net MVC and Jquery is it makes client side coding so easy. Here is a good example. Lets say I want to have a html select control that updates automatically when it’s changed
First we build a Controller that has an action to output our view and an action to accept posts

   1: [HandleError]   2: public class HomeController : Controller   3: {   4:     public ActionResult Index()   5:     {   6:         UserModel userModel = new UserModel(){UserId = 1,Type = UserTypes.User};   7:     8:         return View(userModel);   9:     }  10:    11:     [AcceptVerbs(WebRequestMethods.Http.Post)]  12:     public ActionResult UpdateUserType(UpdateUser input)  13:     {  14:         var result = new {Succss = true, Message = "Updated"};  15:         return Json(result);  16:    }  17: }

notice UpdateUserType() has the attribute “[AcceptVerbs(WebRequestMethods.Http.Post)]” this forces it to only allows posts, also it takes a complex type, in this case a class of type UpdateUser.
Here is a quick over view of the model objects we are going to be using

   1: public class UserModel

   2: {

   3:     public int UserId { get; set; }

   4:     public UserTypes Type { get; set; }

   5: }

6:

   7: public enum UserTypes

   8: {

   9:     User = 1,

  10:     PowerUser = 2,

  11:     Admin = 3

  12: }

13:

  14: public class UpdateUser

  15: {

  16:     public int UserId { get; set; }

  17:     public UserTypes Type { get; set; }

  18: }

one of the nice this is that MVC takes care of the mapping and casting for us as you’ll see in a second.
The view is a very simple and strongly typed for the UserModel, first build the select control

   1: <select name="SelectUserType" onchange="UpdateUserType(this,<%=Model.UserId%>)">

   2:     <%foreach (UserTypes item in Enum.GetValues(typeof(UserTypes)).Cast<UserTypes>())

   3:     {

   4:             if(item ==  Model.Type)

   5:             {

   6:                 %><option selected="selected" value="<%=((int)item).ToString() %>"><%=item.ToString() %></option><%

   7:             }

   8:             else

   9:             {

  10:                 %><option value="<%=((int)item).ToString() %>"><%=item.ToString() %></option><%

  11:             }

  12:     } %>

  13: </select>

this loops through the UserTypes Enum to populate the select control and selects the value that’s selected in the view Model and we add an onchange that points to a javascript function that we pass the control and the UserId from the model into.
Next we add the javascript function(fyi this requires Jquery)

   1: <script type="text/javascript">   2:     function UpdateUserType(sender, userId) {   3:         var model = { UserId: userId, Type: sender.value };   4:         $.post("/home/UpdateUserType",   5:             model,   6:            function (data) {   7:     8:                alert("Was Successful: " + data.Succss);   9:                alert("Message: " + data.Message);  10:            });  11:     }  12: </script>

First we build a JSON object where the property names need to match the properly names in UpdateUser, Asp.net MVC needs this for mapping, and then we use Jquery $.post passing in the action URL, the JSON object we just built, and a javascript function to handle the returned data and your done.

A quick and easy way to add Ajax to any control and as always here is a link to the demo project http://bob-the-janitor-sample-code.googlecode.com/svn/trunk/ajaxMadeEasy/

The evil of process over craftsmanship

noreply@blogger.com (Bob The Janitor (Richard)) — Thu, 22 Jul 2010 08:23:00 +0000

If you had a choice between a well build home that cost more money but wasn’t going to cost very much to maintain or a house that didn’t cost very much, but was going to cost a lot more to maintain in the long run, which would you choose. If you own a house and have had to deal with the upkeep of the home I can almost guarantee you would much rather have the first house, even if fixing the major problems is free (most new houses come with a one year guarantee from the builder), if you have ever had to deal with getting your builder to fixed things, free or not, the stress and aggravation almost makes it not worth it. So why do so many software development teams almost insist on building software like second house was built.

By taking the time to build a quality product, it will cost more up front, talented people cost money, to do the job right takes time(time=money) but because it was done right the first time it costs a lot less in the long run.
Unfortunately in the software development world it’s far to common to just get it out and worry about fixing known problems later. This becomes even more painful when the schedule or process becomes the reason for poor craftsmanship.

Here are two problems, one is building a house the other is building software:

1) A builder starts working on a house and discovers that the property has a high water table and that every spring there would be flooding in the crawlspace. The two ways to solve this problem are: bring in enough dirt to raise the house up so the crawlspace doesn't get flooded or add subpumps to pump the water out. Both fix the problem, while the subpumps are going to be quicker to setup, it’s not going to get out all of the water and it will add to maintenance costs which in the long run will be much more expensive.

2) A pair of developers are tasked with writing a service for importing data into a database and half way though writing it they find out the data has duplicate records and some other garbage data. There are two ways to solve this, build a validator to remove the garbage data or pass it off and have the DBAs create a job to remove the garbage from the database.

I’m fairly sure we would all much rather take the time to put in the fill dirt then have to deal with the maintenance of having sub pumps, and yet for some reason it’s very common for developers to be told “we don’t have time to add a filter” and to push the task of removing the garbage from the database onto the DBAs, or worse yet just live with the garbage data.

We know that when the process(schedule/tasking) trumps craftsmanship(using subpumps or having the DBAs remove bad data) you end up with a lower quality product with higher overall costs so why do we still do it?
The tools of the software craftsman: TDD, design patterns(command, strategy, observer, etc ), decoupled design, source control, continues integration, paired programming, etc. and by using any of them you will end up with better software with lower overall costs and yet it feels like it’s a constant battle to get them into our development process. We need to take a stand, we need to be craftsman and insist on building quality products.

Using the Observer Pattern

noreply@blogger.com (Bob The Janitor (Richard)) — Fri, 28 May 2010 13:23:00 +0000

At work we are reading “Head First Design Patterns” and discussing the “Observer Pattern” and some people wanted to see a code example.
The first part is the the class that manages the observer classes

   1: public class EventManager<T>   2: {    3:     private Dictionary<string, ISubscriber<T>> _subscribers = new Dictionary<string, ISubscriber<T>>();   4:     public Dictionary<string,ISubscriber<T>> Subscribers   5:     {   6:         get { return _subscribers; }   7:         set { _subscribers = value; }   8:     }   9:    10:     public void Notify(T newState)  11:     {  12:         foreach (var observer in Subscribers.Values)  13:         {  14:             observer.State = newState;  15:             observer.Update();  16:         }  17:     }  18: }

In this example I created a generic class that has two basic parts a collection of subscribers or observers and a method that loops though and updates the state of the subscribers. I used a Dictionary<string,ISubscriber<T>> to make it easy to manage my subscribers based on a key, and because ISubscriber<T> is also a generic its a very flexible and strongly typed way to work with the subscribers.

Next let’s take a look at ISubscriber<T> interface

   1: public interface ISubscriber<T>   2: {   3:     T State { get; set; }   4:     void Update();   5: }

it’s that simple, I use generics to determine the state and the input type for the update method, here is an example implementation

   1: public class TweetLocation : ISubscriber<Location>   2: {   3:     public ITwitter TwitterInterfacer = new FakeTwitterClient();   4:     public Location State { get; set; }   5:     6:     public void Update()   7:     {   8:         TwitterInterfacer.TweetMessage(string.Format("currently at ({0},{1})",State.Lat,State.Lon));   9:     }  10: }

TweetLocation is observing Location information and calls a Twitter class to Tweet the new location when updated, for something a little more complex

   1: public class SaveLocation : ISubscriber<Location>   2: {   3:     public ILocationReposigtory LocationRepository = new FakeLocationRepository();   4:     public static EventManager<string> ErrorHandler = new EventManager<string>();   5:     6:     public Location State{get;set;}   7:     8:     public SaveLocation()   9:     {  10:         ErrorHandler.Subscribers.Add("ErrorMailer",new ErrorMailer());  11:     }  12:    13:     public void Update()  14:     {  15:         bool success = LocationRepository.SaveLocation(State);  16:         if (!success)  17:         {  18:             ErrorHandler.Notify("Failed to save location");  19:         }  20:     }  21: }

SaveLocation is basically the same as TweetLocation except it has it’s own EventManager to handle errors from failed attempts at saving the location.

Finally here is an example of actually using it

   1: class Program   2: {   3:     public static EventManager<Location> LocationHandler = new EventManager<Location>();   4:     5:     static void Main(string[] args)   6:     {   7:         LocationHandler.Subscribers.Add("Repository",new SaveLocation());   8:         LocationHandler.Subscribers.Add("Twitter",new TweetLocation());   9:    10:         Location currentLocation = new Location(){Lat = 111,Lon = -121};  11:    12:         LocationHandler.Notify(currentLocation);  13:    14:         Console.ReadKey();  15:    16:         currentLocation.Lon = 1211;  17:         LocationHandler.Subscribers.Remove("Twitter");  18:         LocationHandler.Notify(currentLocation);  19:    20:         Console.ReadKey();  21:           22:           23:     }  24: }

This is a simple console app that demonstrates adding subscribers, updating state, and removing a subscriber.

A real world example of using “Observer Pattern” is a service bus like NServiceBus or MassTransit, where an event driven application needs to send messages to one or more subscribers.

As always here is a link to the project source.

Another walk in the cloud with Amazon Web Services

noreply@blogger.com (Bob The Janitor (Richard)) — Wed, 12 May 2010 06:05:00 +0000

Talking a look at some of the offering that Amazon Cloud Services has I decided to take a look at Amazon Simple Storage Service or simply Amazon S3.

Like I wrote in “A walk in the Cloud” the Amazon cloud can be accessed though a web service so you have the option of rolling your own tools or using their API lib. The has SDK has defiantly improved and the install process is a lot easier now. Before you had to download the source, build the project, etc, now all you have to do is download AWSSDKForNET and install it. This adds the Clint to your GAC, and add templates into Visual Studio, if you still want to see what they are doing under the hood you can still download the source.

Amazon may not provide you with any tools but there are a few free ones that work fairly well. CloudBerry Explorer is a fairly solid tool for managing your S3 storage, it looks kind of like an ftp client and it lets you manage multiple accounts, create buckets, upload/download content, generate web URLs(http and https), search, etc. Another client is the Firefox plug-in S3Fox, basically the same as CloudBerry but it runs in Firefox.

Pulling data from S3 is relatively simple, this is a code sample for pulling your list of buckets, then building a list of links to the images in each bucket

   1: AmazonS3 s3Client = AWSClientFactory.CreateAmazonS3Client(   2:     ConfigurationManager.AppSettings["AWSAccessKey"],   3:     ConfigurationManager.AppSettings["AWSSecretKey"]);   4:     5: ListBucketsResponse response = s3Client.ListBuckets();   6:       7: foreach (S3Bucket bucket in response.Buckets)   8: {   9:     HtmlGenericControl header = new HtmlGenericControl("div")  10:     {  11:         InnerText = bucket.BucketName  12:     };  13:    14:     DivlistOfImages.Controls.Add(header);  15:    16:     ListObjectsRequest request = new ListObjectsRequest  17:      {  18:          BucketName = bucket.BucketName  19:      };  20:     ListObjectsResponse imageList = s3Client.ListObjects(request);  21:    22:     foreach (S3Object s3Object in imageList.S3Objects)  23:     {  24:         HtmlAnchor imageLink = new HtmlAnchor  25:        {  26:            InnerText = s3Object.Key  27:        };  28:         string bucketName = bucket.BucketName;  29:         string objectKey = s3Object.Key;  30:         GetPreSignedUrlRequest preSignedUrlRequest = new GetPreSignedUrlRequest  31:          {  32:              BucketName = bucketName,  33:              Key = objectKey,  34:              Protocol = Protocol.HTTP,  35:              Expires = DateTime.Now.AddDays(7)  36:          };  37:    38:    39:         imageLink.HRef = s3Client.GetPreSignedURL(preSignedUrlRequest);  40:         DivlistOfImages.Controls.Add(imageLink);  41:     }  42: }

it’s that simple.

With this you can have your content be managed by another department with a tool like CloudBerry and remove the work of updating images and other forms of content.

As always here is a link to the sample code project

Taking Telerik’s Just Mock for a test drive

noreply@blogger.com (Bob The Janitor (Richard)) — Fri, 16 Apr 2010 03:10:00 +0000

Telerik has released a beta of JustMock (a mocking framework) they claim can easily mock anything including sealed classes, non-virtual methods, and static classes. If they can do this great!, but lets see just how well this actually works by taking a look at some of the biggest pains to test: HttpContext and SqlConnection.

HttpContext Test

Test: Can I mock HttpContext, set a value, and get the value, in this case Error

   1: ErrorLoger target;   2: private const string TestError = "Test Error";   3: public MockILogger MockLogger;   4:     5: [SetUp]   6: public void Setup()   7: {   8:     target = new ErrorLoger();   9:     HttpContext mockContext = Mock.Create<HttpContext>();  10:     Mock.Arrange(() => mockContext.Error).Returns(new Exception(TestError));  11:     target.Context = mockContext;  12:     MockLogger = new MockILogger();  13:     target.LoggerInterface = MockLogger;  14: }  15:          16: [Test]      17: public void LogError_SetsLoggerMessageEqualToContextErrorMessage_Test()  18: {  19:    target.LogError();  20:    21:    Assert.AreEqual(TestError,MockLogger.Message);  22: }

Result: Just Mock crashes when it tries to mock HttpContext.

SqlConnection Test

Test: Can I mock a SqlConnection and open a connection with out really opening a connection.

   1: private DataRequest target;   2: private bool SqlConnectionOpened;   3:     4: public void SqlConnectionOpenedCalled()   5: {   6:     SqlConnectionOpened = true;   7: }   8:     9: [SetUp]  10: public void Setup()  11: {  12:     SqlConnectionOpened = false;  13:     target = new DataRequest();  14:       15:     var mockSqlConnection = Mock.Create<SqlConnection>();  16:     Mock.Arrange(() => mockSqlConnection.Open()).DoInstead(SqlConnectionOpenedCalled);  17:     target.Connection = mockSqlConnection;  18: }  19:    20: [Test]  21: public void GetUserList_Test()  22: {             23:     List<string> actual = target.GetUserList();  24:     Assert.AreEqual(true, SqlConnectionOpened);  25: }

Result: Just Mock was able to create the mock without crashing but when I try to set alternate functionality to the Open method, recording that I called Open, it crashes saying invalid connection string. My question is why does it care about a connection string when I’m setting behavior, unless I’m missing how to set this up.

Conclusion

As you can see in the examples the syntax is nice and simple, unfortunately Just Mock failed to pass either of my test and to be honest I’m not surprised, it’s in early beta and I tested it against the hardest problems I can think of to solve, something that none of the other mocking frameworks I have looked at even attempt.

What really impressed me was that while working on this I tweeted about having problems and within a couple of hours @hkosev (Hristo Kosev) from Telerik, who isn’t one of my followers, tweeted me asking what I was doing to get the errors and asked me if I would mind sending him the source for what I was doing so they could solve the problem, without even asking for help, very nice.

As always here is the link to my source code.

Using what works

noreply@blogger.com (Bob The Janitor (Richard)) — Mon, 05 Apr 2010 04:24:00 +0000

What’s with the hating, can’t we all just get along? The agile guys vs. non-agile, Windows vs. Mac vs. Linux/Unix, and we can’t forget the language wars. So why do we get so entrenched in the belief that the way we do it is right and everyone else is wrong; call it ego, pride, or something else, it doesn't really matter, why do we do it. By nature we are problem solvers so why do we have such a hard time accepting other’s ways/tools for solving problems?

Agile vs. Non-agile

Having worked in both agile and non-agile environments, I have to say I like agile, I think if done right for most development environments it has a lot of advantages, the key here is if it’s done right, and for most environments. If your daily scrum meeting are taking more then 30min, there is strong possibility your doing something wrong. On the other side with a few exceptions, the idea of specifying every feature your project is going to have before anything is written is, well naive at best. At the patterns and practices conference Billy Hollis make some comments that really upset a fair number of people in the agile community, and in return they responded with that Billy doesn't know what he’s talking about, etc. To this my thought was your both right and at the same time wrong.

Agile doesn't work for everyone, some teams just can’t do it, and that’s ok, you shouldn’t feel bad because your not doing it the way the “cool kids” are, the important thing is to find a development methodology that works for your team. Having said that, there are a lot of practices that have come out of the agile methodologies that can greatly benefit the non-agile groups, I don’t care what you say unit testing benefits everyone, having a build deploy server helps everyone, etc.

To the agile zealots out there, agile is A WAY to develop successful and maintainable software, it’s not the only way. Lots of very successful projects have been written with non-agile methodologies and lots of very unsuccessful projects have been written using agile. Everything has it’s advantages and disadvantages, let’s face it the larger your team the harder agile gets. As in most things zealotry is wrong, I don’t care how good the dogma is, it’s not more important then getting the job done, the most important thing is to get the job done, so find what works for you and do it.

Windows vs. Mac vs. Linux/Unix

The OS fan boy wars are a never ending battle between people who for the most part really just don’t get it. So let’s break down the fan boys:

Windows fan boys: For the most part they have never used anything but windows, everyone else uses windows so it must be the best at everything so it doesn't matter what Microsoft provides it’s the best.
Mac fan boys: Their like the popular kids in school that you don’t understand why their popular because no one really like them that much, and then you add on a devotion that is almost like a cult with Steve Jobs as their messiah. Some are disillusioned windows fan boys others where born into the Mac fold and all have a limited understanding of what’s out there.
Linux/Unix fan boys: Seeing themselves as elite or ultra power users they look down at windows and Mac users as lower life forms, yet at the same time they are constantly defending their OS.

I must make the disclaimer that I am a former Linux fan boy and to this day I see a lot of faults with windows, but on the flip side I see a lot of improvements that have been made in windows that make it a lot more attractive, but I still really like Linux, funny that I’m a .NET developer. All three OS have their strengths and their weaknesses and all three work as a development platform, albeit some are better at some development stacks(.NET is easier on windows) and some development requires a specific OS(if you are doing IPhone development you need to have Mac), in all honestly all three work well and it really comes down to what the user likes out of their OS. I have known some very talented graphic artists that don’t like Macs and have been very frustrated by having to use one, on the flip side I have a Ruby developer friend that really likes Macs.

So in the end it really comes down to is how can we make what we have work for what we are doing, and choosing the right tool for the job, and for who is doing it verses following some techno dogma.

Giving them what they need, verses what they ask for

noreply@blogger.com (Bob The Janitor (Richard)) — Sun, 04 Apr 2010 22:45:00 +0000

A little while ago I was contacted to see if I could help an elderly member of my congregation, she needed some help building a mail box post. The phone call went something like this

her: Do you have a table saw?

me: ya, what do you need?

her: I need to cut up a 4x4 post

me: ok, what are you building?

her: A mail box post and I need to cut some braces at 45 degree angle, you can do that with a table saw right?

me: Bring your stuff over and I’ll help you build it.

This is a perfect example of someone who knew what they needed, but not how to get it. What she needed was some supports cut with 45 degree angles, and she knew that a table saw could make 45 degree angle cuts, and true a table was could do it, BUT it’s really not the right tool, you’re far better off using a miter saw.

This got me thinking how often we as “tech” have been asked to do something only later to find out it’s really not what they needed or wanted.

a possible example:

marketing: we need a share point server.

tech: sure, who needs access

marketing: The graphics designer

tech: you want a share point server for one person?

marketing: yes

tech: what is she going to use it for?

marketing: tracking the changes made to images

tech: you want a share point server to track image images revisions

marketing: yes, is there a problem with that?

tech: Let me show you subversion.

This is a very good example of someone having a need and coming up with a solution without consulting with anyone, and asking for the solution without explaining the problem. In this case I used a marketing person, but this could just as easily be a developer not consulting with operations, or a DBA not consulting with the developers.

Far to often we are asked to do things with little or not explanation to the problem we are providing a solution for and we don’t ask questions as to what we are solving and this really is a disservice to who we are helping.

The VS2010 Preview

noreply@blogger.com (Bob The Janitor (Richard)) — Fri, 02 Apr 2010 14:08:00 +0000

At the local VS2010 Even held in Boise, Id we where given a basic over view of what's in VS 2010, while some of these feature are innovate, like the testing tools, there was a lot of Microsoft playing catch up with some of the other IDEs out there. This by no means is a complete list of what is in VS2010, this is just what was presented at the preview, with a little bit of my commentary added by me.

Team project collection

One of the new features is the Team project collection is TFS, while this sounds great, I fail to see where this is a big step up from other source control systems like clear case, subversion, etc. that have been doing this from the beginning, is this Microsoft playing catch up? or am I missing something.

Project templates

With so many more project types in VS2010 there are a lot more project templates, including Database projects, something to keep in mind is the DB projects only support SQL Server 2005+, sorry SQL Server 2000 people, an interesting side note, you can get a plug-in from Quest software for supporting Oracle.

Extension manager

One of the long awaited features for VS is the Extension Manager, as a user you can manage what extensions you have on your system and browse for new extensions in the online gallery. While I really like this feature, lets face it, Microsoft was really late to the party with this, seeing that most other IDEs (Eclipse, Sharp Develop, Mono Develop, etc ) have been doing this for years.

Multi framework targeting

VS2010 now has multi framework support, now vs2008 did support .NET 2.0, 3.0, 3.5 but under the hood it's still the 2.0 CLR. In VS2010 you can run code on the 2.0 and 4.0 CLR, this was something the Microsoft reps where very proud of. Unfortunately this is another area where Microsoft was late to the party where a lot of the other IDEs have been supporting multiple frameworks for years and it get even more prevalent when you get outside the .NET stack.

IDE improvements

The IDE improvements in VS is one area where Microsoft is a leader. Where VS2008 added refactoring tools VS2010 improved upon them, but you're still going to have to pull ReSharper out of my cold dead hand. A quick overview of the IDE improvements in VS2010

improved refactoring tools
improved debug tools
new IDE profiles (environment templates)
improved MVC support
performance monitoring
Local deployment build with end to end packaging for web application
improved SharePoint development integration

.NET 4.0 CLR improvements

With VS2010 comes the 4.0 CLR, not only did they improve the performance of the framework they also made strides to make better use of multi core systems. Lets face it multi threading in general is painful, to solve this .NET 4.0 has an improved threading pooling engine, they now fully support the functional language F# out of the box, and have full support plinq. Plinq lets you spread the work of a linq Query across multiple cores by figures out at runtime the most optimize query solution. To use plinq all you have to do is add AsParallel to your linq query and .NET takes care of the rest.

Code Contracts was added to .NET to provide a non language specific way to express coding assumptions. Basically you can specify preconditions, post conditions, and object invariants in order to improve testing via runtime checking and enable static contract verification, how this affects me, I’m not sure yet.

Improved Testing tools

An area that has come a long way in VS2010 are the testing tools, unfortunately some of the more interesting tools are only available in VS2010 Ultimate, but Microsoft did add a stand alone testing product called Microsoft Test and Lab Manager, this lets you do most of your test management with out VS.

Testing features in VS2010:

UI testing tools that allow you to code/record UI tests, this looks kind of like the Art of Test (Telerik has a re-branding) tool for Web testing but this supports all .NET UIs
Test runner monitors what your testers are doing by allowing you to watch what's going on while testing in order to better track what the testers are doing, this includes customizable data collection to filter out irrelevant data, the ability to add video of how this bug was produced that can be added to the defect tracking system, and displays the step by step test steps to the testers .
Virtual system manager (Hyper-V is supported but VMware and Virtual box support is expected post RTM) for setting up and managing testing environments.
PEX- automated white box testing tool
IntelliTrace is basically a trace and profile tool
The test impact analysis tool specifies what test are going to be affected by code changes, for large code bases with lots of tests this allows more targeted testing for TDD.

What you get in the Test Lab and Manager

Test case management
Create UI tests just like in VS2010
Test runner for monitoring what your doing in the test just like in VS2010
Can import test cases from Excel
Can configure testing data including network connectivity (throttling connectivity )

Team Foundation Server

TFS has an updated admin tool http://www.codeplex.com/TFSAdmin that generally improves managing your server and users. To better fit in the enterprise level space TFS also added clustering with load balancing and build server pooling; for small shops this may not be that big of a deal but it's nice to know for if and when you're no longer a small shop.

One of the major complaints with TFS 2008 was the build system was painful to use and almost required a dedicated builder, this has been supposedly fixed with 2010 by moving to a work flow based build system, I'm waiting to see if this actually fixes the problem.

An interesting new addition Excel Services integration in TFS. This allows reporting, updating stories, tasks, test cases, etc. with out having to use the Test lab or VS2010. The basic idea is the business people can use a tool they are familiar with to interact with TFS. Also the excel service integration doesn't require any CALs to use.

To my disappointment there is not a migration tool to move from other source control systems (subversion) to TFS yet, but supposedly it's on the way, so if you're currently using subversion your going to have to wait.

Agile Software Development with TFS

Some of the improvements to TFS are in it's support of agile development, with project templates for agile out of the box and the ability to customize your tickets (they are just xml). All work items are queryable using Excel Services allowing your product owners and scrum master to know exactly what is going on at any time.

The build server now supports ATDD (Acceptance Test Driven Development) and tie in UI tests, Unit Tests, Integration Tests, etc.

An interesting addition is the ability to create a team portal and wiki in Share point automatically.

Conclusion

I'm excited to start using VS2010 all in all I'm impressed with what it dose and how it works.

ASP.NET Controls, even the 3rd party controls are great, until you really try to use them

noreply@blogger.com (Bob The Janitor (Richard)) — Fri, 29 Jan 2010 15:11:00 +0000

Over the years I have had a kind of love hate relationship with asp.net web controls and after having some frustration recently I decided to rant about it.

Conceptually it’s nice idea, the asp.net controls abstract away a lot of the “web development” so you can focus on just creating your application and not futzing around with html inputs, and creating elaborate javascript, and they give you a kind of sort of state; and for about 90% of the time they do everything you want them to do.

Were they fall down is really in two places:

In all reality not getting that last 10% really isn’t the controls fault it’s trying to be everything to every body and you really can’t do that. This is even true the for expensive 3rd party controls, granted vendors like DevExpress, Component One, and Telerik make some very nice controls (a lot better then the stock controls from MS) I would even say they give you an additional 5%, and for the most part they make developing web forms easier and faster, BUT they still fall down when you really push them hard and then it feels like your spending all of your time tweaking their control verses just getting your application written.
The cost of getting that statefullness by using viewstate can sometimes crush your application, like most things it’s fine in moderation, unfortunately ViewState can quickly explode in size and blot your application, creating HUGE page sizes, slow responses and if it gets big enough it starts to corrupt and your applications starts to error, fun! Once again the 3rd party vendors tend to make better controls with less viewstate.

So what is the solution, first learn about webforms controls and how they work, then create some server controls of your own. If you look at previous posts I talk about how to create different types of controls and I’m only scratching the surface. By rolling your own controls you can focus on getting them to do exactly what you want them to do and that might be the solution to getting the last 5% of the functionality you need. Using Asp.net controls is one of the places where it’s really easy to get started with very little knowledge and quickly get sucked under. This is defiantly a place where if you don’t understand how it works it can and will come back to get you.

Finally if you can’t get that last little bit of functionality, well for the most part you just have to deal with it. Sorry to say but we are getting to a point where the development work on the web is going beyond what the underlying technology just can support.

Unit Testing For Javascript

noreply@blogger.com (Bob The Janitor (Richard)) — Tue, 19 Jan 2010 06:56:00 +0000

Recently I had to write some fairly substantial javascript, and in the process I was reminded of how fast javascript, like most scripting languages, and get out of hand really quick. I took a step back and thought why should I work in javascript any different then I do in other language? Just because it’s a scripting language doesn't make it any less valid of a development platform, and I can apply the same design pattern and principles I would with anything else.

So The first thing I did was went looking for a unit testing framework and I found JSUnit. JSUnit is available from http://www.jsunit.net/ and is a port of the JUnit framework to javascript. The entire testing framework and test runner is written in javascript so I can use it anywhere you use javascript and in any development platform(php, ruby, Perl, java, .net, etc).

Getting started I have this javascript function I want to test

        1: function addTwoNumber(x, y) {       2:     var result = x + y;       3:     return result;       4: }

so first I create an html page and add the jsUnitCore.js and my .js file containing this function (almost all of your javascript really should be in .js files for a number of reasons, but that’s another blog post).

   1: <html>       2:     <head>       3:         <script language="JavaScript" src="jsUnitCore.js"></script>       4:         <script language="JavaScript" src="javascriptCode.js"></script>       5:     </head>       6:     <body>               7:     </body>       8: </html>

then to add test cases I create functions inside a script tag in the body of the html page like so

   1: <body>       2:     <script type="text/javascript">       3:         function test_addTwoNumber_TwoNumbersAreAdded() {       4:             var result = addTwoNumber(2, 2);       5:             assertEquals("Adds 2 values together", 4, result);       6:         }       7:         8:     </script>       9: </body>

to tag a function as a test, simply start the function off with the text “test” and the test runner will pick it up and run it. The assert is done with the function assertEquals provided by the jsUnitCore.js file and takes 3 prams (test description, expected value, and actual result) and to run the test you simply open the testRunner.html page in the jsunit dir in a browser

then add the file location and run the tests, it’s that simple. If you look at the screen shot you will notice that I’m using opera, for what ever reason I couldn’t get the test runner to work in Firefox, every time I would try and run my test file I would get a time out error, The funny thing is it works in IE, Chrome, and Opera just fine, weird.

Using WCF to build fast and lean web applications

noreply@blogger.com (Bob The Janitor (Richard)) — Sun, 13 Dec 2009 06:41:00 +0000

Recently I ran into a problem where I needed to reduce the size of a page, we had a page with a lot of drop down controls that may or my not be used. The problem with this was the size of the html was huge, every one of the controls was fully populated with over 50 items, next the view state was equally huge storing all of that content. The Solution, using WCF to load the control’s content on demand.

Starting off we need to get WCF configured, and this confused me, I had to manually register WCF in IIS, WHAT!! ok to save you the hassle of having to research how to do this, execute c:\WINDOWS\Microsoft.NET\Framework\v3.0\Windows Communication Foundation\ServiceModelReg.exe –i and your good to go.

We have two options for populating the dropdowns, you can use a 3rd party control like Telerik’s radcombobox, or roll your own, which in some ways is fairly simple but rather involved, for right now I’m going to show you how to roll your own, to see how to use radComboBox see here.

Lets start with the WCF service, create a Ajax enabled WCF service. For what ever reason I had to remove the namespace to get this to work, and the examples I found online had it removed as well, this is something I’m going to research more on later. Next we need to build a data entity to hold the data, nothing fancy just something like this

        1: public class Item       2: {       3:     public string Text { get; set; }       4:     public string Value { get; set;}       5: }       6:         7: public class Items : Collection<Item>       8: {}

next we build the service, in this case I’m just building some data.

   1: [ServiceContract(Namespace = "")]       2: [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]       3: public class DataService       4: {       5:     [OperationContract]       6:     public Items GetData()       7:     {       8:         Items myItems = new Items();       9:         for (int i = 0; i < 5; i++)      10:         {      11:             Item newItem = new Item()      12:                {      13:                    Text = string.Format("value {0}", i),       14:                    Value = i.ToString()      15:                };      16:             myItems.Add(newItem);      17:         }      18:         return myItems;      19:     }      20: }

when you add the Ajax enabled WCF service some items will be added to the system.serviceModel section of the web config in this case it looks like this

   1: <system.serviceModel>       2:   <behaviors>       3:    <endpointBehaviors>       4:     <behavior name="DataServiceAspNetAjaxBehavior">       5:      <enableWebScript />       6:     </behavior>       7:    </endpointBehaviors>       8:   </behaviors>       9:   <serviceHostingEnvironment aspNetCompatibilityEnabled="true" />      10:   <services>      11:    <service name="DataService">      12:     <endpoint address="" behaviorConfiguration="DataServiceAspNetAjaxBehavior"      13:      binding="webHttpBinding" contract="DataService" />      14:    </service>         15:   </services>      16:  </system.serviceModel>

if your not able to get your service to work with the Namespace, and you remove it, make sure to also remove it from the contract attribute in the endpoint node of the service node.

Next we add the service reference to the page using the script manager tag

   1: <asp:ScriptManager ID="scriptManager" runat="server">       2:     <Services>       3:         <asp:ServiceReference Path="/DataService.svc" />       4:     </Services>       5: </asp:ScriptManager>

Now we can access the webservice with javascript. First we need to have a dropdown control to work with, for this we are going to just use a plain old html select tag and add an ID and a runat=”server”.

   1: <select        2:     id="dropDownList"        3:     runat="server"        4:     enableviewstate="false"        5:     style="width:200px;"        6:     onfocus="populateDropDown(this);">       7: </select>    

something else I have done here is I set enableviewstate="false" this solution doesn't use any view state so for the “cool kids” out there using MVC, this solution works for you as well. Next add the javascript to populate our dropdown, as you can see in the select tag we have a populateDropDown function that is called with onfocus.

   1: var Control;       2: function populateDropDown(dropdown) {       3:     Control = dropdown;       4:     DataService.GetData(dropDownRequest_onSuccess, onFailure);       5: }

Accessing the service is made easy by using the script manager, all we have to do is call javascript object created by the script manager with the same name as the service contract in this case it’s “DataService” and call the function with the same name as our service method “GetData”. The function takes 2 delegate functions that act as event handlers as parameters, in this case it’s dropDownRequest_onSuccess and onFailure. At this point I would like to say I’m in no way a javascript expert, if you know of a better way to any part of the javascript code by all means do it, and let me know.

   1: var selectedOptionValue;       2:         3: function dropDownRequest_onSuccess(result) {       4:     Control.options.length = 0;       5:     for (var x = 0; x < result.length; x++) {       6:         var opt = document.createElement("option");       7:         opt.text = result[x].Text;       8:         opt.value = result[x].Value;       9:         if (result[x].Value == selectedOptionValue) {      10:             opt.setAttribute("selected", "true");      11:         }      12:         Control.options.add(opt);      13:     }      14: }      15:        16: function onFailure(result) {      17:     window.alert(result);      18: }

The dropDownRequest_onSuccess function clears (if any) options from the select tag, then loops though the result from the webservice, creating option elements, setting their text and value then checking to see if the value matches the value of the selectedOptionValue var and if they do it sets that option as selected then adds it to the options collection of the select control.

The onFailure is called when the service call fails, and for this we are just doing a simple alert to say it failed.

The next part is getting the data out when the page is submitted, because we are not using any view state we can’t get the value the same way we would with a regular asp.net control, we have to pull it from Request.Form collection.

   1: string value = Request.Form[dropDownList.ID];

Finally we need to add a way to set an option as selected. The code to set the selected option is already there we just have to utilize it by setting the value of var selectedOptionValue, to do this we use the ClientScript.RegisterStartupScript like this

   1: private void setValue()       2: {       3:     string script = string.Format("setpopulateDropdown('{0}',{1});", dropDownList.ClientID, Request.Form[dropDownList.ID]);       4:     ClientScript.RegisterStartupScript(typeof(Page),"setDropdownValue",script,true);       5:            6: }

to call this javascript function

   1: function setpopulateDropdown(controlId, value) {       2:     Control = document.getElementById(controlId);       3:     selectedOptionValue = value;       4:     populateDropDown(Control);       5: }

This sets the control to be updated, set the selected value, then populates the the control from the webservice.

Like I said it’s kind of a long process but you can cut down your page size a lot if your doing multiple dropdowns with large amounts of data that may not be used.

As always the full source code for this project is available (here).

First look at Visual Studio 2010 Beta 2

noreply@blogger.com (Bob The Janitor (Richard)) — Fri, 23 Oct 2009 06:13:00 +0000

Visual studio 2010 Beta 2 is out, so lets take a look at some of the changes:

The new WPF UI is a nice clean face lift.
The new extension manager makes getting, updating, and managing plug-ins, templates, and controls(Telerik has almost their entire product line available) from the web easy, my only real issue with the extension manager is I can’t find a way to load plug-ins that aren’t in the gallery, and a lot of my favorite plug-ins(Ghost doc and R#) aren’t supported yet.
The removal of the Team Studio versions, the Team Studio versions where confusing and over priced. The new SKUs are VS 2010 Professional, VS 2010 Premium, and VS 2010 Ultimate. For the full product descriptions see the Visual Studio Product page.

Some of the things that didn’t change:

Adding a reference is still slow and painful.
The testing frame work really hasn't changed much, although the test seem to run faster.

Things that are not quite there yet:

Intellisense doesn’t work very well, but this may be a configuration setting.
The number of supported plug-ins is limited, but that is understandable seeing that the plug-in model has completely changed

All in all I really like Visual Studio 2010 and I’m really excited for when it’s ready for prime time.

Taking the pain out of code documentation

noreply@blogger.com (Bob The Janitor (Richard)) — Sat, 17 Oct 2009 14:52:00 +0000

I have never known a developer that liked writing document let alone writing code document, well I take that back there was one guy but he had *Issues* and we’ll just leave it at that. I have heard all of the excuses, and in the end it still comes down to, we would rather write code then write about the code.

One common statement coming from the TDD/DDD methodologies is that the unit tests document the code; while this is great if we have the unit test, but even then a little documentation would still be useful so we don’t have to dig though unit test to figure out how to use a library. Another favorite excuse is the method names document themselves, granted having intelligently named methods and variables make understanding the code a lot easier(and we’ll get into that latter) but short of having the average method name be 40+ chars long this really isn’t practical either.

Luckily the are some tools to make writing code documentation much easier. For starters the .NET compiler can be configured to generate XML documentation files by setting an xml output file in the project build configuration. The xml content is created from specially formatted XML comments that looks like this

        1: /// <summary>   2: /// Saves the contact.   3: /// </summary>   4: /// <param name="contact">The contact to be saved.</param>   5: /// <returns>   6: /// A true or false result of the successful saving this contact   7: /// </returns>   8: public bool SaveContact(Contact contact)

You can write this by hand or use a tool like the GhostDoc plug-in for Visual Studio. GhostDoc will auto generate documentation based on configurable rules for the different objects, classes, method, properties, etc. One of the very nice features about being able to configure the documentation rules is you can add additional item like remarks that say when it was documented and by who.

The second nice thing about using GhostDoc is the rules used to figure out what to put into the documentation can be used to make sure your using intelligent names, it’s not always right but it can be a good indicator for how good of names your using.

So why add this? This gives you two advantages, first it adds intelligence for your code, next it allows you to create MSDN like documentation using the .NET documentation generator Sandcastle.

Sandcastle can be downloaded from http://sandcastle.codeplex.com/ and provides a command-line interface for building your documentation from the .dll and .XML file generated by the .net compiler making it easy to add documentation generation to your automated build system. For the user it’s a little clunky and painful to use, if you want to build the documentation without scripting, there is an app for that, the Sandcastle Help File Builder located at http://www.codeplex.com/SHFB.

Basically this lets you build a configuration that can include what is documented, the layout of the documentation, adding headers, footers, errors for missing items etc. and when you’re all said and done you get documentation that looks like this

it’s that easy.

Not ready for Inversion Of Control, just use a factory for now

noreply@blogger.com (Bob The Janitor (Richard)) — Wed, 14 Oct 2009 07:04:00 +0000

There has been a lot of discussion latterly in the blog world about using inversion of control or IOC, some claiming it’s to hard to understand, it complicates development, and it’s unnecessary; the other side saying quit complaining it’s not that hard, it enforces good design and makes code more maintainable. To this I’m going to take the vary controversial position that they are both right.

Inversion of control can be intimidation the first time you use it, it adds a bit of complexity and you can write quality applications with out it. On the other side once you “get it” IOC really isn't that hard it encourages separation of responsibilities, and makes it much easier to test making regression testing and refactoring much easier.

So how do we get all of the advantages with out adding all of the complexities of an IOC container, simple just use a software factory class. For those who don’t know, basically a factory class is just away to abstract and consolidate the logic for getting your code dependencies.

Let’s say you have some code for accessing data from Amazon’s simpleDB

        1: public class ContactData : IContactData   2: {   3:     private Proxy simpleDBProxy;   4:     public Proxy SimpleDBProxy   5:     {   6:         get   7:         {   8:             if (simpleDBProxy==null)   9:             {  10:                 simpleDBProxy = new Proxy();  11:             }  12:             return simpleDBProxy;  13:         }  14:         set  15:         {  16:             simpleDBProxy = value;  17:         }  18:     }  19:     const string DomainName = "Contacts";  20:    21:     public Contacts GetContacts()  22:     {  23:         Contacts myContacts = new Contacts();  24:    25:         SelectRequest request = new SelectRequest  26:         {  27:             SelectExpression = string.Format("SELECT * FROM {0} ", DomainName)  28:         };  29:         SelectResponse response = SimpleDBProxy.Service.Select(request);  30:    31:         var contacts = from item in response.SelectResult.Item  32:                          select new Contact()  33:                                     {  34:                                         Email = item.Attribute.GetValueByName("Email"),  35:                                         Name = item.Attribute.GetValueByName("Name"),  36:                                         Phone = item.Attribute.GetValueByName("Phone"),  37:                                         ID =  item.Name  38:                                     };  39:         myContacts.AddRange(contacts);  40:         return myContacts;  41:     }  42:    43:     public Contacts GetContactsByName(string contactName)  44:     {  45:         Contacts myContacts = new Contacts();  46:    47:         SelectRequest request = new SelectRequest  48:         {  49:             SelectExpression = string.Format("SELECT * FROM {0} where Name='{1}' ", DomainName, contactName)  50:         };  51:         SelectResponse response = SimpleDBProxy.Service.Select(request);  52:    53:         var contacts = from item in response.SelectResult.Item  54:                        select new Contact()  55:                        {  56:                            Email = item.Attribute.GetValueByName("Email"),  57:                            Name = item.Attribute.GetValueByName("Name"),  58:                            Phone = item.Attribute.GetValueByName("Phone"),  59:                            ID = item.Name  60:                        };  61:         myContacts.AddRange(contacts);  62:         return myContacts;  63:     }  64:      65:     public bool SaveContact(Contact contact)  66:     {  67:         List<ReplaceableAttribute> attributeList = new List<ReplaceableAttribute>  68:            {  69:                new ReplaceableAttribute().WithName("Email").WithValue(contact.Email),  70:                new ReplaceableAttribute().WithName("Name").WithValue(contact.Name),  71:                new ReplaceableAttribute().WithName("Phone").WithValue(contact.Phone)  72:            };  73:         contact.ID = Guid.NewGuid().ToString();  74:         bool success = false;  75:         try  76:         {  77:             if (!SimpleDBProxy.Domains.Contains(DomainName))  78:             {  79:                 SimpleDBProxy.AddDomain(DomainName);  80:             }  81:             PutAttributesRequest action = new PutAttributesRequest  82:               {  83:                   ItemName = contact.ID,  84:                   Attribute = attributeList,  85:                   DomainName = DomainName  86:               };  87:             PutAttributesResponse response = SimpleDBProxy.Service.PutAttributes(action);  88:             success = true;  89:         }  90:         catch (Exception requestException)  91:         {  92:             success = false;  93:         }  94:    95:         return success;  96:     }  97: }

now because this implements the IContactData interface

   1: public interface IContactData   2: {   3:     Contacts GetContacts();   4:     Contacts GetContactsByName(string contactName);   5:     bool SaveContact(Contact contact);   6: }

we can use it anywhere we would use IContactData, for example here we have an application that uses both local and remote contacts

   1: public class ContactsRequests   2: {   3:     private IContactData ContactData;   4:     public bool UseLocalContacts { get;set; }   5:     6:     public Contacts SearchContactsByName(string contactName)   7:     {   8:         if (UseLocalContacts)   9:         {  10:             ContactData = new LocalContactData();  11:         }  12:         else  13:         {  14:             ContactData = new ContactData();  15:         }  16:         return ContactData.GetContactsByName(contactName);  17:     }  18:    19:     public Contacts GetContacts()  20:     {  21:         if (UseLocalContacts)  22:         {  23:             ContactData = new LocalContactData();  24:         }  25:         else  26:         {  27:             ContactData = new ContactData();  28:         }  29:         return ContactData.GetContacts();  30:     }  31:    32:     public bool AddContact(Contact newContact)  33:     {  34:         return ContactData.SaveContact(newContact);  35:     }  36: }

now this works but there are a few problems, first there is no way to test it’s functionality without testing the functionality of LocalContactData and/or ContactData with a little simple refactoring

   1: public class ContactsRequests   2: {   3:     private IContactData contactData;   4:     public IContactData ContactData   5:     {   6:         get   7:         {   8:             if (contactData==null)   9:             {  10:                 if (UseLocalContacts)  11:                 {  12:                     contactData = new LocalContactData();  13:                 }  14:                 else  15:                 {  16:                     contactData = new ContactData();  17:                 }  18:             }  19:             return contactData;  20:         }  21:         set  22:         {  23:             contactData = value;  24:         }  25:     }  26:     public bool UseLocalContacts { get;set; }  27:    28:     public Contacts SearchContactsByName(string contactName)  29:     {            30:         return ContactData.GetContactsByName(contactName);  31:     }  32:    33:     public Contacts GetContacts()  34:     {  35:        return ContactData.GetContacts();  36:     }  37:    38:     public bool AddContact(Contact newContact)  39:     {  40:         return ContactData.SaveContact(newContact);  41:     }  42: }

we remove the instantiation logic from the method and move it to a public property this way we can set the ContactData property to a mock object and test the specific logic of the methods in this class, now the only problem with this is everywhere we want to use IContactData we have to perform the same logic, and basically reproduce the same code over and over again. This is where factories come in, if we build a factory like this

   1: public static class DataFactories   2: {   3:     public static IContactData GetContactInterface(bool isLocal)   4:     {   5:         IContactData myContactData;   6:         if (isLocal)   7:         {   8:             myContactData = new LocalContactData();   9:         }  10:         else  11:         {  12:             myContactData= new ContactData();  13:         }  14:         return myContactData;  15:     }  16: }

Then we just implement it like this

   1: public IContactData ContactData   2: {   3:     get   4:     {   5:         if (contactData==null)   6:         {   7:             contactData = DataFactories.GetContactInterface(UseLocalContacts);   8:         }   9:         return contactData;  10:     }  11:     set  12:     {  13:         contactData = value;  14:     }  15: }

your applications don’t know or care how they got there class for getting contact all they know is they did, where this really comes in handy is if you have to change out how you handle your local contacts from let’s say an xml file to a database, the only place you have to change your code is in the factory.

Congratulations you are now 90% of the way there for using a IOC container, you have a single place for handling all of your instantiation so once you decide to use IOC you just change how the factory works from having logic that decides what class to insatiate to pulling it from the IOC container, it’s that simple.

Truth be told I always start with a factory and then later “IF” I need the functionality of an IOC I’ll add it. In the end an IOC container really isn’t nearly as scary as it seems to be, and in the same token it isn’t nearly a vital as some people would like to claim, it’s a tool that can be used to solve specific problems, but 90% of the same problems can be solved using a factory.