Now that I’ve played around with EJS for a while, I can say I’m fairly comfortable with it, and love the syntax. It just makes sense to me. But recently, I came across another templating framework, called JAML, or HAML for Javascript (GitHub Page), and it addresses one of my main concerns with EJS. I’ll get to what that was in a little bit. First, let’s look at some JAML syntax:

Example of JAML syntax

Pretty nice, eh? And it’s still easily tucked-away separate from your functional Javascript code. You could create a JS file for each template object, i.e. “Products.jaml.js”, “Orders.jaml.js”, etc, then include them on the page before you require the rendered output/HTML in your functional code.

One of the problems I was running into with EJS was that I needed to make sure the paths to my .ejs files were always correct, regardless of the page the user was looking at. So I had to create absolute URL references to the EJS file via directly, “/somepath/someotherpath/products.ejs”. And that’s fine, but I had more than a few issues while debugging since my production environment was at http://somesite.com and my local site was at http://localhost/myproject/. So when my code asked for “/somepath/someotherpath/product.ejs” it would work fine in production, but it would fail in JS. I came up with ways to use a variable that would get me to the right path, so it’s wasn’t insurmountable, but it was something to keep in mind. Obviously, JAML fixes that by keeping your templates as regular Javascript that can be put into .js files and included in regular <script/> blocks. Nice.

Now let’s do the same comparison I did for jQuery vs EJS. First we start off with a products array.

var products = [
{
id:0,
desc:"product 0",
price: 10.50
},
{
id:1,
desc:"product 1",
price: 1.25
},
{
id:2,
desc:"product 2",
price: 5.60
}
];

And since you’ve already seen what EJS looks like, here’s the JAML syntax:

Jaml.register('product',function(pProduct){
li({cls:"product"},
a({href:"/product/"+pProduct.id},"product "+pProduct.id+" ($"+pProduct.price+")")
);
});

Jaml.register('products',function(pProducts){
ul({cls:'products'},Jaml.render('product',pProducts.products));
});

You’ll notice that I had to do this in a two-step process (i.e. two calls to the register() method). This is a limitation of how the collections/partials process works. I created a template for what an individual product looks like, then I created a template to how a collection of products works; inside of a UL tag, with a product partial for each product object inside of pProducts.products. Not too bad, but it’s a little more work vs EJS, but, if you think about it in the “partials” methodology, it’s not a bad mental-leap.

And the output is as it should be:

<ul class="products"><li class="product">
  <a href="/product/0">product 0 ($10.5)</a>
</li>
<li class="product">
  <a href="/product/1">product 1 ($1.25)</a>
</li>
<li class="product">
  <a href="/product/2">product 2 ($5.6)</a>
</li>
</ul>

Definitely going to have to try out JAML on some of my larger projects to see how it fairs. I imagine it’ll do very well. Thanks to Ed Spencer for this cool product!

Had a little time to kill between tasks a few weeks ago, and Googled to see if I could find a solution to all these dreaded string-concatenations I was finding throughout pieces of our Javascript codebase at work. They were piecing together HTML code (in strings) and attaching objects’ data into the HTML. I stumbled upon EJS (http://embeddedjs.com) and fell in love instantly!

It allows you to create HTML templates, with Javascript placeholders, not unlike Ruby on Rails or ASP.Net. Their main page has a great, little interactive demo. Go check it out, and come back. I’ll probably still be here.
…

Back? Great! So now you’re probably a little excited if you haven’t seen that before. Otherwise, humor me for a bit while I stay geeked-out over this.

It is such a simple, and elegant solution to the problems I was griping to myself about, that I couldn’t wait to test it out for myself. And at the same time, I thought I’d write up this little post about it, comparing jQuery as a templating medium, vs EJS. Here we go.

To start, we need some Javascript objects, so I’ve created a simple array of three simple “product” objects.

products:

var products = [
{
id:0,
desc:"product 0",
price: 10.50
},
{
id:1,
desc:"product 1",
price: 1.25
},
{
id:2,
desc:"product 2",
price: 5.60
}
];

Now that I’ve got some data to work with, let’s create a list to show off the data in HTML. First, we’ll use jQuery. This example is really trivial, but it’s just an example, so I’m not going to split-hairs here. First I grab the UL that will hold the HTML once I’m through adding my product data, then for each product in my products array, I create an LI, and add some attributes/text to them.

jQuery:

var jquery_products = $("#jquery_products");
$.each(products,function(){
var li = $("<li/>").addClass("product");
var a = $("<a/>").appendTo(li);
a.attr("href","/product/"+this.id);
a.html(this.desc + " ($"+this.price+")");
jquery_products.append(li);
});

Pretty simple, eh? And that will output the following HTML:

<ul id="jquery_products">
<li class="product">
<a href="/product/0">product 0 ($10.5)</a>
</li>
<li class="product">
<a href="/product/1">product 1 ($1.25)</a>
</li>
<li class="product">
<a href="/product/2">product 2 ($5.6)</a>
</li>
</ul>

Now, let’s see how EJS stacks up. First, I grab the UL that will hold the HTML that will be output from my EJS template, then, I create a new EJS template, pointing to my template file, product.ejs, and then render the contents using the array of products.

EJS:

var ejs_products = document.getElementById("ejs_products");
var html = new EJS({url: 'scripts/templates/product.ejs'}).render(products);
ejs_products.innerHTML = html;

But we’re only half-done. We now need to define product.ejs, which is below:

product.ejs:

<% for(var i=0; i < this.length; i++) {%>
<!-- Get the current product, "this" is the products array that was passed in-->
<% var product = this[i]; %>
<li class="product">
<%= link_to(product.desc + " ($"+product.price+")", "/product/"+product.id) %>
</li>
<% } %>

Nice and clean. And very maintainable. The output is the same as the jQuery output:

<ul id="ejs_products">
<li class="product">
<a href="/product/0">product 0 ($10.5)</a>
</li>
<li class="product">
<a href="/product/1">product 1 ($1.25)</a>
</li>
<li class="product">
<a href="/product/2">product 2 ($5.6)</a>
</li>
</ul>

I definitely will be using EJS from now on as my Javascript templating framework. jQuery works just fine, but I believe for maintainability’s sake, I will keep my HTML separate from my Javascript as much as possible. It just “feels” right.

The only caveat I have is that you need to make sure you’ve got the right path to your EJS template file. Since your Javascript runs on the current page, and therefore, that current page’s URL, you’ll need to make sure you’ve got the right absolute, or relative path specified to reach the EJS template file. The best thing you can probably do is either always use the absolute path, “/scripts/path_to_template_files/my_template.ejs”, or, create a javascript variable in your page somewhere that always points to the root of your website, and append your template file directory from there.

var base_url = "http://mywebsite.com";
//...snip
var html = new EJS({url:base_url+"/scripts/templates/my_template.ejs"}).render(data);

I few weeks ago I picked up “Rails for .NET Developers”,by Jeff Cohen and Brian Eng, and practically read it from cover-to-cover in about a week and a half’s time. It was a very informative read, and I was looking for a jumping-off point to really get into Rails, and I figured a book supposedly written for “my kind” would be a great way to start.

After reading through the book, I realized that all I really needed was an intermediate to advanced guide for Rails, and didn’t necessarily need any correlation to .NET. The book did a fine job presenting most of what I wanted, but as a programmer I just need to learn syntax, guidelines and cool tricks and I can begin to write in any language—that’s typical for most any programmer. If I had to do it all over again, I may have chosen a different book that just focused on Rails and not one that compared it to another language in an effort to ease the transition.

Now that I’ve got a handle on Rails, I’ve been digging into the Ruby language, and trying to pick up more tips on that front. It was beyond the scope of the book to go into a lot of depth on Ruby, so I’m not docking it points because of that.

The Good: Great introduction to developing Rails apps. Straightforward examples and nice side-by-side comparisons of .NET code vs the Ruby/Rails equivalent (you honestly save many lines of code going the Rails way, being that Ruby is such an opinionated language).

The Bad: None really, just a personal critique that I should have picked up a book that was only focused on Rails.

The Ugly: Reminders of how horrible development in .NET webforms can be. From now on, I only want to develop in MVC platforms. Clean, testable separation of concerns.

Some side projects of mine have led me down the path of getting more familiar with Drupal (http://drupal.org) and I have to say that it’s a wonderful and powerful CMS. It definitely has a lot of features that provide the convention or configuration mantra that I’m growing to love the more I use Ruby on Rails.

Theme creation from scratch was a bit of a hurdle, but I think I’m over the hardest learning curves, and it only took a few hours to pick up and run with. I was creating a menu using Drupal’s menu system, and was thinking to myself, “Ok, I’m going to have to figure out how to dig into the backend of Drupal and set some ‘active’ flags when this menu item is clicked, so I can add a nice background to visually show the user where they are in the menu.” But, to my surprise, and delight, Drupal had me covered. If the menu item points to content on the site you’re building, it automagically looks at the current URL, and matches it with the menu item, and adds an “active-trail” class to the menu item’s LI.

Anyway, I just wanted to say a few words, sharing my excitement for Drupal. I may post more on it as time goes on, but if you’re looking for a free CMS to try out, with an expansive community of supporters and module writers, you should really check out Drupal.

Part 1
Part 2

This post is going to go over Automapping using Fluent NHibernate with regards to my blogging engine.  If you’re unfamiliar with the concept of automapping, you should browse James Gregory’s introductory post. Basically, we gained the benefit of XML-less configuration when mapping our data transfer objects (DTO) to database tables and columns with Fluent NHibernate over plain old NHibernate. Mapping was achieved through “mapping” classes, one per DTO, so if you had a “User” class, you’d also need a “UserMap” class that told FluentNHibernate how to map each property in your class to the column in a database table.  Automapping removes the requirement of creating mapping classes and relies on conventions over configuration. Here we go.

First off, in order to get automapping to work, you’ll need to generate an AutoPersistenceModel object that encompasses your automapping parameters.  I’ll post the code and then I’ll go through it step by step.

public AutoPersistenceModel GetPersistenceModel()
{
    return AutoPersistenceModel.MapEntitiesFromAssemblyOf<Blog>()
        .WithSetup(a => a.IsBaseType = type => type == typeof (DomainEntity))
        .Where(type =>
               type.Namespace.EndsWith("Domain.Model") &&
               !type.IsAbstract &&
               type.IsClass &&
               type.GetProperty("Id") != null)
        .ConventionDiscovery.AddFromAssemblyOf<IdConvention>();
}

As you can see, this class has only one responsibility at the end of the day, to generate an AutoPersistenceModel.  The AutoPersistenceModel class is the heart of the automapping configuration.  Let’s go through it.

return AutoPersistenceModel.MapEntitiesFromAssemblyOf<Blog>()

This line lets FluentNHibernate’s automapping framework know where to find the DTOs.  The framework will look through the assembly and attempt to map each class to a table in the database.  How does it know not to map a particular class, such as a base class? Read on

.WithSetup(a => a.IsBaseType = type => type == typeof (DomainEntity))

This line lets the automapping framework “know’ that DomainEntity is a base type, and not a type or class that needs to be mapped to a table in the database.

.Where(type =>
    type.Namespace.EndsWith("Domain.Model") &&
    !type.IsAbstract &&
    type.IsClass &&
    type.GetProperty("Id") != null)

Here’s where it gets a little more interesting.  The above code is where we tell the framework exactly which classes we’d like to map to a database table.  We first let it know that the class should be in the Domain.Model namespace, should not be abstract, should be a class, and that there should be a property named “Id” that should not be null.

.ConventionDiscovery.AddFromAssemblyOf<IdConvention>();

A simplistic line of code, but it actually does quite a bit as we’ll soon find out.  Now that we’ve told Fluent NHibernate Automapping how to find DTOs to map to database tables, we now would like to tell it what to do with them by defining some conventions.  See James Gregory’s quick overview to the convention framework by visiting his blog.

To see why I have the above line of code, maybe it would make sense to see inside of my “Core” solution and its architecture/topology:

I just want to focus in on the Conventions folder/namespace and go through each of those convention classes to see what is going on in each, and why they are needed.

public class HasManyConvention : IHasManyConvention
{
    public bool Accept(IOneToManyPart target)
    {
        return true;
    }

    public void Apply(IOneToManyPart target)
    {
        Type t = target.GetType();
        if(t == typeof(OneToManyPart<Blog>))
            target.KeyColumnNames.Add("OwnerId");
        if(t == typeof(OneToManyPart<Post>))
            target.KeyColumnNames.Add("AuthorId");
        target.Cascade.All();
    }
}

This class is responsible for handling the HasMany convention, which is used for all OneToMany relationship mappings. In our case, we have a few of these mappings:

• User has many Blogs (via User’s property IList<Blog> Blogs)
• User has many Posts (via User’s property IList<Post> Posts)
• Blog has many Posts (via Blog’s property IList<Post> Posts)

As you can see the Accept() function simply returns true, which in turn is letting the automapping framework know to apply this convention to all classes being mapped.  And what is being applied? Well everything happening inside of the Apply() function, of course

First off, I’m getting the type of the target, which is of type IOneToManyPart. The target parameter is automagically in the form of OneToManyPart<Blog> or OneToManyPart<Post> depending on which OneToMany relationship is being mapped (User.Blogs, User.Posts or Blog.Posts).  Now that I have the type of OneToMany relationship, I compare it to the current target’s mapping.

If the type is OneToMany<Blog>, then I need to tell the FluentNHibernate Automapping framework to use column “OwnerId”.  This may seem weird, but maybe this SQL query generated by NHibernate will help a little.  The code is getting a User with Id 1, and returning all the Blogs owned by that user.

NHibernate: SELECT user0_.Id as Id1_0_, user0_.Password as Password1_0_, user0_.Email as Email1_0_ FROM "User" user0_ WHERE user0_.Id=@p0; @p0 = '1'
NHibernate: SELECT blogs0_.OwnerId as OwnerId1_, blogs0_.Id as Id1_, blogs0_.Id as Id0_0_, blogs0_.LastUpdated as LastUpda2_0_0_, blogs0_.Title as Title0_0_, blogs0_.Description as Descript4_0_0_, blogs0_.OwnerId as OwnerId0_0_ FROM "Blog" blogs0_ WHERE blogs0_.OwnerId=@p0; @p0 = '1'

If I did not tell FluentNHibernate to use the column “OwnerId”, it would instead use “User_Id” by convention, since in the Blog class, Owner is of type User.  I do not want this convention, so I must override it in order for the mapping to work successfully.  Yes, it’s more work for me to not use the convention, but, I wanted to illustrate the point. 

The same idea goes for a target of type OneToMany<Post>.  I tell the framework to use column “AuthorId” instead of it’s normal “User_Id” convention.

The last convention added to a OneToMany relationship is how to cascade updates/deletes/etc, by letting the framework know to cascade all.  So now when I delete an object through NHibernate, NHibernate will run a SQL query to cascade the delete properly.

Let’s move on to the next convention:

public class HasManyToManyConvention : IHasManyToManyConvention
{
    public bool Accept(IManyToManyPart target)
    {
        return true;
    }

    public void Apply(IManyToManyPart target)
    {
        target.Cascade.All();
    }
}

This convention is much simpler as it just states that for every ManyToMany relationship, I only want the cascade all behavior. The same goes for a HasOne relationship, but for full-disclosure’s sake, I’ll post the code below:

public class HasOneConvention : IHasOneConvention
{
    public bool Accept(IOneToOnePart target)
    {
        return true;
    }

    public void Apply(IOneToOnePart target)
    {
        target.Cascade.All();
    }
}

Another simple, but important convention to my database model, is my IdConvention:

public class IdConvention : IIdConvention
{
    public bool Accept(IIdentityPart target)
    {
        return true;
    }

    public void Apply(IIdentityPart target)
    {
        target.ColumnName("Id");
    }
}

I believe that by convetion, FluentNHibernate’s AutoMapping framework looks for the ID column in a database by using the DTO class name and appending “Id” to it.  I do not want this behavior, so I’m letting the framework know that I want it to know that when looking for the identity column in the database for each table, look for a column named “Id”.

The last custom convention that I laid out was the ManyToOne relationship convention.

public class ReferencesConvention : IReferenceConvention
{
    public bool Accept(IManyToOnePart target)
    {
        return true;
    }

    public void Apply(IManyToOnePart target)
    {
        target.ColumnName(target.Property.Name + "Id");
    }
}

Again, I’m apply this convention to all mapped classes that have a ManyToOne relationship and then I’m letting the framework know that the column names will be in the format of Property name + “Id”.  An example of a ManyToOne relationship in my database model is between Blogs and Users.  A blog has an Owner property (which is a user), so to map this relationship, we’re telling FluentNHibernate to look for a column named “OwnerId” in the Blog table.  And that does it for my conventions.

Alright, let’s figure out where we are right now.

• I’ve got a class, BlogAutoPersistenceModelConfig, that creates an AutoPersistenceModel object
• The class also let’s the FluentNHibernate framework know that each of my DTOs have a base class of DomainEntity
• The class also adds some criteria to the framework to let it know which DTOs to map, and which ones to ignore.
• The last step is to add conventions to the mapped classes to determine how to handle different relationship types, and where to find the ID column in a table.

Now that we’ve got an AutoPersistenceModel configured, we can proceed to create an ISessionFactory as part of the NHibernate framework.  That’ll be a topic for the next post, and it should be quite a bit shorter.

Hope this was a little helpful in your automapping ventures.

• Rolling my own blog engine, part 1

Initially I was going to jump into my tests that I had written to exercise my data access layer via FluentNHibernate, but, I’ve decided that I wanted to get to AutoMapping first before I move ahead. Before I get to that though, I have to do a little housekeeping.

I wanted to get rid of the “RegisteredUser” class, and just have a “User” class. At the same time I saw a place to abstract a little code through inheritence, so I created a DomainEntity class (code is below).  While I was at it, I made my other classes, Blog and Post, inherit from DomainEntity as well.

public class User : DomainEntity
{
    public virtual IList<Blog> Blogs { get; set; }
    public virtual IList<Post> Posts { get; set; }
    public virtual string Email { get; set; }
    public virtual string Username { get; set; }
    public virtual string Password { get; set; }

    public User()
    {
        Blogs = new List<Blog>();
        Posts = new List<Post>();
        Email = string.Empty;
        Username = string.Empty;
        Password = string.Empty;
    }

}

public class DomainEntity : IEquatable<DomainEntity>
{
    public virtual Guid Id { get; set; }

    public virtual bool Equals(DomainEntity other)
    {
        if (ReferenceEquals(null, other))
        {
            return false;
        }

        if (ReferenceEquals(this, other))
        {
            return true;
        }

        return other.Id.Equals(Id);
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj))
        {
            return false;
        }

        if (ReferenceEquals(this, obj))
        {
            return true;
        }

        if (obj.GetType() != GetType())
        {
            return false;
        }

        return Equals((DomainEntity)obj);
    }

    public override int GetHashCode()
    {
        return Id.GetHashCode();
    }

    public static bool operator ==(DomainEntity left, DomainEntity right)
    {
        return Equals(left, right);
    }

    public static bool operator !=(DomainEntity left, DomainEntity right)
    {
        return !Equals(left, right);
    }
}

Now we’ve got a more simply named class (User) and I added a layer of abstraction by inheriting from a DomainEntity class.  The DomainEntity will become the base class of our other classes; Blog and Post and will handle things such as the Id property, as well as equality validation.  Their new code makeover, is as follows:

public class Blog : DomainEntity
{
    public virtual IList<Post> Posts { get; set; }
    public virtual string Title { get; set; }
    public virtual string Description { get; set; }
    public virtual DateTime LastUpdate { get; set; }
    public virtual User Owner { get; set; }

    public Blog()
    {
        Posts = new List<Post>();
        Title = string.Empty;
        Description = string.Empty;
        LastUpdate = DateTime.MinValue;
        Owner = new User();
    }
}

public class Post : DomainEntity
{
    public virtual string Title { get; set; }
    public virtual string Body { get; set; }
    public virtual DateTime LastUpdate { get; set; }
    public virtual DateTime PublishDate { get; set; }
    public virtual User Author { get; set; }

    public Post()
    {
        Author=new User();
        Title = string.Empty;
        Body = string.Empty;
        LastUpdate = DateTime.MinValue;
        PublishDate = DateTime.MinValue;
    }
}

Great, now things are setup in a way that we can move on to AutoMapping these classes to the database using a convention over configuration.  Last time I had a lot of code that I had to generate by hand in order to map each class to the database, and in turn, a table in that database.  It wasn’t terribly backbreaking work, but, there’s a simpler way, especially when you have more and more classes that need mapping to tables in the database.

I’ll go over my AutoMapping solution next time.

I had another programming problem dawn on me the other day;

Given a string of words, separated by spaces, reverse each words’ letters, but not the order of the words in the string.

Sounds simple enough. If you were to have the string “abc defg”, the output would be “cba gfed”. A simplistic brain puzzle, but I admittedly took more time than I thought necessary to solve it. 

Assumptions:

• I’d need a method that can reverse a given string
• I’d be manipulating arrays of characters, not actual “strings”

I wrote my first test using those assumptions:

public void CanReverseCharactersOfAString()
{
    string testString = "abcdefg";
    string expectedOutcome = "gfedcba";

    string reversedString = Manipulator.ReverseString(testString);

    Assert.AreEqual(expectedOutcome, reversedString);
}

So I wrote this test without writing any other code, and as you can see, it’s expecting a class called “Manipulator” that has a static method “ReverseString”.  Yes, I suppose I could have written a string extension method, but I chose not to. No reasoning behind that decision.

Of course, this test will fail because the project won’t build. Let’s go fill in the blanks.

public class Manipulator
{
    public static string ReverseString(string s)
    {
        char[] chars = s.ToCharArray();

        ReverseAtIndices(ref chars, 0, chars.Length);

        return new string(chars);
    }

    private static void ReverseAtIndices(ref char[] chars, int low, int high)
    {
        char temp;
        int i = 0; // 'i' will help us get from one side of the string to the other, working backwards
        for (int j = low; j < high; j++)
        {
            int end = high - 1 - i++;   // 'end' is the other index to swap letters with
            if (j &amp;amp;gt;= end)               // if the current index 'j' is greater than or equal to 'end', we can stop swapping
                break;                      //Why? Because we've reached the half-way point in the string.
            temp = chars[j];
            chars[j] = chars[end];
            chars[end] = temp;
        }
    }

}

I realized I’d need a helper method, ReverseAtIndices, that takes a reference to a character array and then a low and high integer.  The character array is the string to be reversed. Low and high are the indices in the array to start and stop the reversing, respectively (so I guess I could refactor and call them “start” and “stop”, eh?)

The method loops through the array and swaps letters at opposite ends of the array. For instance, in the array of [a,b,c], ‘a’ would get swapped with ‘c’, and ‘b’ would get swapped with itself. If we allowed the loop to go just one step further, it would swap ‘a’ and ‘c’ again, outputting [a,b,c] instead of the desired [c language=",b,a"][/c].

Running the test CanReverseCharactersOfAString() passes, so on to the next challenge; reversing letters of words in a string while not changing the order of the words.  Let’s write a test for it:

[Row("abc def", "cba fed", ' ')]
[Row("abc", "cba", ' ')]
[Row("abc defg hij kl", "cba gfed jih lk", ' ')]
[Row("hello world!", "olleh !dlrow", ' ')]
public void CanReverseLettersInStringOfWords(string input, string expected, char delimiter)
{
    Assert.AreEqual(expected, Manipulator.ReverseLettersInAStringOfWords(input, delimiter));
}

I decided to use MbUnit’s row-testing capabilities so that I could run the same test with differing inputs without having to write more tests.

As you’ll note, I’ve assumed I’m going to have a new static method in the Manipulator class called ReverseLettersInAStringOfWords. Admittedly, not a great name, but, it’s fairly descriptive for this exercise.  The method takes just two parameters, a string and a character.  The string is, of course, the string of words we want to reverse some letters in, and the character is the delimiter between words.  In this exercise, the delimiter will always be a space, but, we could use this method in the future and easily pass in any delimiter we wanted, such as a comma. 

When writing the actual method, ReverseLettersInAStringOfWords, I had some difficulty getting it to work in the manner I wanted.  I’m pretty sure there are dozens of Google answers out there on this very problem, but, I wanted to solve it without them first. I’ll probably go back and refactor once I see some other solutions.  Here’s the code. It’s a little verbose for my liking, but, again, it hasn’t be refactored yet (basically I’m asking for you to turn a blind eye just this once ):

public static string ReverseLettersInAStringOfWords(string s, char delimiter)
{
    char[] chars = s.ToCharArray();
    char temp;
    int i=0;
    int low, high;
    low = high = i;
    for (i = 0; i < chars.Length; i++)
    {
        // Move the 'high' index up if the delimiter hasn't been found yet
        if(chars[i] != delimiter)
            high = i + 1;
        else
        {
            ReverseAtIndices(ref chars, low, high);
            // Move up the low index now that we've found a delimiter
            //  and reversed some characters
            low = i + 1;
        }
    }
    // The end of the string may not contain a delimiter, so make sure
    //  we reverse the last set of characters
    if(high == chars.Length)
        ReverseAtIndices(ref chars, low, high);
    return new string(chars);
}

With this method written, all the tests pass (thankfully) and we’ve satisfied the guidelines of the problem statement.

Now I’m off to Google some better alternatives

I was reminded just today that it’s been a while since I’ve implemented a linked list from scratch, and it sounded kind of fun.  I also thought that I should create it via a TDD (test-driven development) strategy to give myself an additional +1 to my good-little-coder attribute.

To begin, I’ll do a quick overview of what I needed in order to create a linked list. First, I needed a Node class to hold three values: Next, Previous and Value.  “Next” is a Node-type that holds, you guessed it, the next Node in the list, adjacent to the current Node.  “Previous” is the same concept, except it of course holds the value of the node “in front of” the current node, and “Value” is the currently held value of that node.  For this little demo, I’m not going to use generics, so the LinkedList will be un-typed, so to speak, and therefore Value will actually be an object so that it can old any type.

Next, I’d need a LinkedList class to keep track of the root node, and handle the adding and deleting of nodes in the list. More on that in a bit, we’ve got to write some tests before we delve into this any further!

[Test]
public void CanCreateNewList()
{
    string testValue = "root";
    LinkedList linkedList = new LinkedList(testValue);

    Assert.AreEqual(testValue, linkedList.CurrentNode.Value);
}

[Test]
public void CanAddNodeWhereNextNodeIsNull()
{
    string rootValue = "root";
    string childValue = "child";

    LinkedList linkedList = new LinkedList(rootValue);

    linkedList.AddNode(childValue);

    Assert.AreEqual(linkedList.CurrentNode.Value, childValue);
    Assert.AreEqual(linkedList.CurrentNode.Prev.Value, rootValue);
    Assert.AreEqual(linkedList.Length, 2);
}

[Test]
public void CanAddNodeWhereNextNodeIsNotNull()()
{
    string rootValue = "root";
    string childValue = "child1";
    string newChildValue = "child2";

    LinkedList linkedList = new LinkedList(rootValue);
    linkedList.AddNode(childValue);
    linkedList.Previous(); // root
    linkedList.AddNode(newChildValue);

    Assert.AreEqual(linkedList.CurrentNode.Value, newChildValue);
    Assert.AreEqual(linkedList.CurrentNode.Prev.Value, childValue);
    Assert.AreEqual(linkedList.Length,3);
}

[Test]
public void CannotUsePrevOnRoot()
{
    string rootValue = "root";
    LinkedList linkedList = new LinkedList(rootValue);
    var prevNode = linkedList.Previous();
    var prevPrevNode = linkedList.Previous();

    Assert.AreEqual(rootValue, linkedList.CurrentNode.Value);
    Assert.AreEqual(rootValue, prevNode.Value);
    Assert.AreEqual(rootValue, prevPrevNode.Value);
}

[Test]
public void CannotUseNextOnLastElement()
{
    string rootValue = "root";
    LinkedList linkedList = new LinkedList(rootValue);

}

[Test]
public void CanDeleteNode()
{

    int oldLength, newLength;
    LinkedList linkedList = new LinkedList("root");
    linkedList.AddNode("child");
    oldLength = linkedList.Length;
    linkedList.Delete(1);
    newLength = linkedList.Length;
    Assert.GreaterThan(oldLength, newLength);
}

[Test]
[ExpectedException(typeof(IndexOutOfRangeException))]
public void CannotDeleteNodeWithInvalidIndex()
{
    int oldLength, newLength;
    LinkedList linkedList = new LinkedList("root");
    linkedList.AddNode("child");
    oldLength = linkedList.Length;
    linkedList.Delete(99);
    newLength = linkedList.Length;
    Assert.GreaterThan(oldLength, newLength);
}

[Test]
public void CanGetNodeByGoto()
{
    string rootValue = "root";
    string child1Value = "child1";
    string child2Value = "child2";
    string child3Value = "child3";
    string child4Value = "child4";
    LinkedList linkedList = new LinkedList(rootValue);
    linkedList.AddNode(child1Value);
    linkedList.AddNode(child2Value);
    linkedList.AddNode(child3Value);
    linkedList.AddNode(child4Value);

    Assert.AreEqual(linkedList.Goto(2).Value,child2Value);
}

[Test]
[ExpectedException(typeof(IndexOutOfRangeException))]
public void CannotGetNodeWithInvalidIndex()
{
    string rootValue = "root";
    LinkedList linkedList = new LinkedList(rootValue);

    var node = linkedList.Goto(99);

    Assert.IsNotNull(node);
}

The above tests are the product of my TDD. I created the test, ran the test (they failed), then wrote supporting code to make the test pass. Refactored, repeated, then wrote the next test.

So, what do they do?  The above tests test for the following (if you don’t want to sort through the code):

• Tests that I can successfully create a new LinkedList object
• Tests that I can add a node to a LinkedList object
• Tests that I can delete a node from a LinkedList object
• Tests that I cannot delete a node that doesn’t exist
• Tests that I can quickly “jump to” a node by passing its index
• Tests that I cannot “jump to” a node that doesn’t exist

The code for the Node class:

public class Node
{
    public Node Next { get; set; }
    public Node Prev { get; set; }
    public object Value { get; set; }
}

The code for the LinkedList class:

public class LinkedList
{
    private Node _CurrentNode;
    private int _Count;
    private int _CurrentPosition;

    public Node CurrentNode
    {
        get { return _CurrentNode; }
    }

    public int Count
    {
        get { return _Count; }
    }

    public int CurrentPosition
    {
        get { return _CurrentPosition; }
    }

    public LinkedList(object value)
    {
        _Count = 1;
        _CurrentPosition = 0;

        _CurrentNode = new Node() { Next = null, Prev = null, Value = value };
    }

    public void AddNode(object value)
    {
        if(CurrentNode.Next==null)
        {
            CurrentNode.Next = new Node() {Next = null, Prev = CurrentNode, Value = value};
            _CurrentPosition++;
            _Count++;
            _CurrentNode = _CurrentNode.Next;
        }
        else
        {
            _CurrentNode = _CurrentNode.Next;
            _CurrentPosition++;
            AddNode(value);
        }
    }

    public Node Next()
    {
        if(_CurrentNode.Next != null)
        {
            _CurrentNode = _CurrentNode.Next;
            _CurrentPosition++;
        }
        return _CurrentNode;
    }
    public Node Previous()
    {
        if(_CurrentNode.Prev != null)
        {
            _CurrentNode = _CurrentNode.Prev;
            _CurrentPosition--;
        }
        return _CurrentNode;
    }

    public void Delete(int i)
    {
        var node = this.Goto(i);
        var prevNode = node.Prev;
        var nextNode = node.Next;

        if (prevNode != null)
        {
            prevNode.Next = nextNode;
            if (nextNode != null) nextNode.Prev = prevNode;
        }
        _Count--;
        _CurrentPosition = i - 1;
    }

    public Node Goto(int i)
    {
        if(i>Count-1)
            throw new IndexOutOfRangeException("Index out of range: " + i);
        if(CurrentPosition > i)
        {
            Previous();
            return Goto(i);
        }
        if(CurrentPosition < i)
        {
            Next();
            return Goto(i);
        }
        return CurrentNode;
    }

And that’s really it. I can create a new linked list, add, delete and jump to a specific node. ]]> http://carlfurrow.com/2009/05/tdd-fun-creating-a-linked-list-in-c/feed/ 0 http://carlfurrow.com/2009/05/investment-in-your-developers/ http://carlfurrow.com/2009/05/investment-in-your-developers/#comments Mon, 11 May 2009 12:00:09 +0000 Carl http://carlfurrow.com/?p=23

It is far too common that companies are not investing enough in their coders, and I don’t mean strictly monetary compensation.  Developers need to learn and network with other developers about new projects, technologies and methodologies in order to stay fresh and current.  Developers need to know that they’re not alone in their concerns, and that there is a larger network out there that has either been through what they’ve been through, or has a suggested road map to completion.  I believe there is a strong need to utilize conferences, community involvement, and/or inter-company learning sessions to effectively invest in your developers.

Equipment, equipment, equipment!  It is beyond me why some companies do not put a higher emphasis on high-performing, current equipment for their developers.  Economic reasons aside, laptops should be replaced every two years, I believe, in order to keep up to pace with the newest developer environments, especially when your developer environment is virtualized via VMWare, or Microsoft’s Virtual PC (or even Parallels if developing Windows software on a Mac).  When visiting a local software shop recently, I noticed more than a handful of Dell laptops that were 4 to 5 years old, and the developers were constantly groaning at how long it would take to build.  Regular equipment replacement should be considered a given when your company relies on your developers to turn a profit.

Conferences are an easy fix to a lack of developer investment in a company.  Let the devs pick a yearly conference to go, and listen to the conversations that begin to happen when they return.  Conferences like CodeMash, DevLink, TechEd or the Apple  Worldwide Developers Conference are some great ones, to name a few.

Another way to invest in your developers is to encourage community involvement.  Attending user groups, or volunteering to speak at a conference like KalamazooX or the West Michigan’s .Net University can go a long way in not only improving your developers’ public speaking skills, but it’s also a way to let the community know about your company’s human assets.

One of the development teams I came across on my travels met weekly in a conference room, and discussed a chapter from “Code Complete 2nd Edition” that they had read the week before.  An educated and collaborative discussion of what each developer understood and took from the chapter went a long way in getting every dev on the same proverbial page (gah, pun!).  I thought this was an excellent practice to have, and that was almost five years ago now. I imagine you could even save the expense of buying a book for each developer, and instantiate a weekly web-article review, or find a few problems on StackOverflow.com, or ProjectEuler.com for the team to solve collaboratively.

Investing in your developers can go a long way in helping the team dynamic by getting them to work more closely together as they find each others’ strengths and weaknesses, and not see them as barriers but opportunities for learning.

There is definitely such a thing as having too much process in a development cycle, and, of course, conversely there is definitely such as thing as having too little process.

I like to surround myself with people (well, mostly developers) that believe that a little time investing in a lean process goes a long way. Let’s take, for example, implementing SCRUM meetings, not the entire SCRUM methodology, just the daily meeting.

I was once told that a daily meeting, lasting 5-10 minutes was asking too much, and that the development team would rather just code.  Unfortunately, it turns out that we ended up having one to two hour long meetings every few days to “sync-up” and reorganize with what could have been accomplished in a fraction of that time.

To be honest, I’ve never been a part of a SCRUM meeting, YET! But I can whole-heartedly see the value in it.

• Everyone knows what everyone is working on
• Everyone knows where the “trouble spots” are
• It is not a witch-hunt or a blame-game when problems arise
• No one is stuck “churning” on a particular piece of functionality

SCRUM meetings can be such a simple process, and they don’t (really) have to involve any management intervention. It could be taken upon the developers alone, so that they can all benefit from its outcomes.  With SCRUM, individual failures reflect on the team, and if you start blaming one developer, the team has failed.  I believe that under SCRUM the success or failure of the project is on the team as a whole, so it’s less about pointing fingers and more about solving problems collaboratively.

On the flip side, I’ve had experience in which there was too much process in a developer cycle.  Where the dev team would spend more time in meetings, Monday through Wednesday, than coding.  Every decision had to be deliberated with the core/senior development team, who would then hash it up, and deliver it to the management team, who would then package it and hand it over to the CIO, who would then add notes and pass it back down through the chain.  And the decisions were trivial, such as should we use a drop-down list, or a checkbox group.  These decisions can and sometimes should be left up to the development and user-experience team members, and shouldn’t involve more people than absolutely necessary.

There is a time and place for a process that works for your development team, and finding and implementing that process should definitely be a collaborative effort.  At a minimum a SCRUM-type daily meeting doesn’t add much additional time to your normal routine, but, I believe it will strike up the right kind of collaboration and conversations afterward to keep the project’s momentum going.