John Teague's Blog

Giving Your MVC Views an Identity

jcteague — Wed, 15 Jul 2009 05:01:00 GMT

One of the great CSS tips I got from Zen of CSS was to put an id on the body tag of your html pages. This makes it really easy to use one CSS file for your entire site (a optimization trick) and allow you to target elements on specific page easily without creating a lot of unnecessary content wrappers or bogey class names.

It is also very simple thing to do on MVC sites. Using the convention of Controller+Action give an easy identifier (if you’re using areas or something else you will need to tweak this a little). This simple extension method does all the work for you.

  public static class MasterPageExtensions
     {
         public static string BuildPageIdentifier(this ViewMasterPage masterPage,  ViewContext context)
         {
 
             return string.Format("{0}-{1}", context.RouteData.Values["controller"],context.RouteData.Values["action"]);
         }
     \ 

Now just add this to your MasterPage.

  <body id="<%= this.BuildPageIdentifier(this.ViewContext)%>">
 

It will create html that looks like this.

Now you can write CSS like this to target specific pages on your site.

  #Resident-Edit #VolumeLevel { display:block; margin-bottom:.8em; }

Programming Basics: The for loop can do more than increment an integer

jcteague — Fri, 12 Jun 2009 18:50:00 GMT

This is one of those small things that is easy to forget. Usually when we use a for loop, we'll just incrment over an integer so that we can get a specific item out of some iteration. But you can do much more than that. My current project has a complicated scheduling component and I'm often working with a range of dates. I often need to do something with the days between two dates. I created a TimePeriod class that is created with a start and end date.

public class TimePeriod
    {
        private readonly DateTime _start;
        private readonly DateTime _end;

        public TimePeriod(DateTime start, DateTime end)
        {
            _start = start;
            _end = end;
        }

...

}

Now what I need to do is iterate over all of the days that are between these two dates. I was struggling with this for a while, trying get a clean implementation. Then I remembered that the for loop could do this for me. Instead of using the standard i++ of the loop action, I add a day to the iteration variable. Now I can get every day between the start and end date.

public IEnumerable<DateTime> DaysInPeriod()
{
      for(var d = _start; d <= _end; d = d.AddDays(1))
      {
           yield return d;
      }
}

Once I had this in place, I was able to put on some more convenience methods to cut down on some repetitive tasks I was performing.

public bool Contains(DateTime dateTime)
{
return DaysInPeriod().Contains(dateTime);
}

public bool ContainsTheDayOfWeek(DayOfWeek dayOfWeek)
{
return DaysInPeriod().Any(d => d.DayOfWeek == dayOfWeek);
}

This was nothing Earth shattering, but a real simple abstraction made my life a lot easier.

Ruby and Rake as an executable

jcteague — Wed, 10 Jun 2009 20:05:00 GMT

I've been trying for months to get my partner in crime, Stephen Balkum, to switch to Rake as our default build system. We've been using Nant FOREVER and while it works, I really hate writing Nant scripts.

The problem Stephen had with going to Rake where twofold. One, we're still doing (mostly) .Net apps, so the only thing we'd use Ruby for right now is Rake (hopefully that will change soon too). And Ruby is a pretty big installation if you're only building .Net projects with Rake.

The other, more important, more problem is that we like to have completely self-contained projects. So when a new dev comes online all they have to do is checkout from source control, click build.bat and you are ready to go. You simply can't do that with Ruby and Rake. You must install Ruby and then get all of the gems necessary to run Rake.

Well, Stephen found a way around all of this. He has encapsulated Ruby, Rake, and all dependencies into a single 3mb executable. Now it can be checked in and passed around like any other required tool.

You can read more about it here

Austin Code Camp Schedule

jcteague — Sun, 24 May 2009 20:39:00 GMT

Several people have already mentioned some of the sessions at this year's Austin Code Camp. We've posted the schedule for people to view. We may move some around depending on how the voting goes to make sure there is adequate space for each session. So be sure and check again at the conference.

I'm really excited about this year's line up. I think it's a good mix of nuts and bolts framework usage and best practices & improving your craft style presentations.

As always, the Austin Code Camp is completely free, including food. We are able to do this by the awesome presenters who volunteer their time deliver this information and to our sponosors who help with actual expenses.

If you haven't registered yet, please hurry up and do so. We want to make sure we order enough food for everyone.

I hope to see your there.

Submit Your Austin Code Camp Sessions Now

jcteague — Fri, 17 Apr 2009 05:27:52 GMT

The deadline for submitting session is April 19. If you want to speak at this year’s code camp, better hurry up. We have about 27 sessions submitted so far, most of them 2 hours in length. Also remember, I don’t reject submissions unless I am out of space, which is very unlikely. So if you submit multiple sessions be prepared to do all of them.

For more details on Submitting Session, check out the original Call For Speakers.

Also it’s not too Register or Sponsor

Building Maintainable Web Applications Training Course

jcteague — Thu, 16 Apr 2009 03:54:42 GMT

I am conducting a two day training workshop on Building Maintainable Web Applications. It will be here in Austin TX June 8-9.

The foundational philosophy I and my consulting company believe is that creating applications that are maintainable starts with creating applications that are easy to test. This workshop will show you how to apply design and testing techniques to web applications on the ASP.Net Framework. I am definitely not talking for two days straight, so there will be a lot of hands on experience applying the concepts discussed.

Some of the topics we will be covering include:

Designing Applications for Testability
Unit Testing Strategies
Model View Presenter for ASP.Net WebForms
Asp.Net MVC Framework
Automated Acceptance Testing of Web Applications
Testing JavaScript

The training course is designed for those that have existing ASP.Net 2.0 applications that must extend their lifetime and are also interested in new techniques available, such as the MVC Framework.

The purpose of this training is as much about helping the developer community enhance their skills as anything else. The cost for the entire 2 day workshop is only $200 so that we can cover our costs.

If you have any questions or would like to attend, please contact me through this blog.

Resharper templates: Don't forget the Macros

jcteague — Mon, 06 Apr 2009 04:36:17 GMT

I use Resharper templates (among other features) on a daily basis. Most of them create very small pieces of code that I use VERY frequently. For instance, I have a set of templates that help me build out my test classes and cases very quickly. One of the very cool features you can add to your templates is to use Macros that let's R# do more work for you.

The lates template I created was to create the MockRepository.GenerateStub<Type>() line for me. It’s a simple one liner, with one variable $INTERFACE$

I then added a Macro to the template to guess the type the variable should be.

Now I can use this macro ( it’s named gs) on this line.

And it fills out the generic type of the GenerateStub method for me.

As you can see, this is really a big time saver, especially for the really tedious generic types. Small time optimizations like these add up over a few hundred tests.

Cooking With Pablo: Chicken Cacciatore

jcteague — Wed, 01 Apr 2009 05:03:22 GMT

In this edition of Cooking With Pablo, were going to do one of my favorite one pot dishes: Chicken Cacciatore. Cacciatore means “hunters stew”. This would be a dish that hunters would make while on long hunting trips with whatever game they caught cooked with whatever vegetables were available. Today it more traditionally served with a tomato sauce over pasta or rice.

Ingredients

About 1 lb of chicken. I prefer using thighs or other dark meat, but chicken *** will work too
2 cans of stewed tomatoes.
1 small onion, diced
As much garlic as you like, this is a lot for me
Fresh Basil
Thyme
Oregano
Salt and Pepper

In a large skillet, brown the chicken in some olive oil over medium heat. You just need to brown the sides, so 4-5 minutes on each side. Remove the chicken from the skillet,add the onion and reduce the heat. Sauté the onion until slightly caramelized. Then add the tomatoes, garlic, basil, thyme and oregano. Allow the sauce to simmer for 5 minutes or so, then use a potato masher to crush the tomatoes. Add the chicken back to the pot and simmer for about 45 minutes or until the chicken is done. Serve over pasta or rice with grated parmesan cheese.

Variations

Add mushroom, red peppers or whatever vegetables you like or are handy.

Add about 1/2 cup of dry white wine and reduce for a brighter sauce.

The MVC Template Team Got It Right

jcteague — Fri, 20 Feb 2009 16:04:22 GMT

I just created my first project with ASP.Net MVC RC1 and I had a pleasant surprise!!

As with the beta, when you create a new project with the MVC project template, it creates a AccountConroller as part of the startup code. In the beta, all of the logic to handle user login and authentication was directly in the Action method. This completely violates Separation of Concerns.

With RC1 this code looks much better, they created IFormAuthentication and IMembershipService interfaces and added them to the constructor (for constructor dependency injection) and now all work is delegated to these interfaces.

Kudus MVC team!! This is the correct design for both SoC and for testing purposes. For RTM, could you also include the correct unit tests for this controller to further reinforce the need for testing.

Polymorphism with JavaScript

jcteague — Wed, 18 Feb 2009 05:20:12 GMT

I don’t know if I picked this line up in a book or somewhere else, but the best way to describe the JavaScript language is schizophrenic. The language itself (regardless of the hosting environment) doesn’t know if it’s Object Oriented or Functional. It’s always been my opinion that the functional aspects of the language are more powerful than the OO features, yet the least used. This is probably my most classically trained OOP developers don’t really like JavaScript. The other reason is because most classically trained OOP developers coming from .Net and Java ( myself included) also forget that JavaScript is also a dynamic language. So we try to get the language do things statically as we would expect other “grown up” languages to do.

This is why a lot JavaScript libraries try to add additional layers on top of the language to make it feel more like a static language. Polymorphism is one of those features we expect from an Object Oriented language, yet the language itself doesn’t directly support this the way we expect it to (there are workarounds, but I’m not going into those). But when you remember that JavaScript is dynamic, it become remarkably easy.

In our current project, we are using JQuery to make modifications to a legacy web application, where we REALLY don’t want to work on the server-side logic. In this app we have two form that are exactly the same (for our purposes at least) except for one little detail. On one page, a critical piece of information is in a drop down list, while on the other page, it just static html content. So we need a little polymorphic behavior here, to retrieve this information differently.

To start with, we are using the Module Pattern to both contain our public methods in a single scope and to hide some of our methods from the public api. So we exposed a method in our return object that we expect to override.

var module = function(){
 // private methods
 //return object that has our public methods
 return{
   getImportantField: function(){ alert("this method is not implement, write your own"}
 }
}();

On the page where we need to get this from the drop down list, we include these script files:

<script type="text/javascript" src="Module.js"></script>
<script type="text/javascript" src="GetImportantFieldFromDropDown.js"></script>

Now we can change the behavior of our method my replacing it at runtime.

module.getImportantField = function(){
    //access the field via the drop down
}

And on the page where we need it from the text, we’ll include another file that changes the behavior of the method in question

<script type="text/javascript" src="Module.js"></script> 
<script type="text/javascript" src="GetImportantFieldFromDropDown.js"></script>

And of course change the behavior appropriately:

module.getImportantField = function(){
    //access the field via the html text
}

This approach takes advantage of the fact that browsers load source files in the order in which they are listed. Also the fact that JavaScript treats methods like variables and you can replace their value at any time. This opens up many new opportunities for structuring your code in dynamic languages that are not possible with static languages. Yes I know you can do similar things with delegates in C#, but you get my point. I’m still learning what is possible with dynamic languages and utilize that to its fullest extent.

Austin Code Camp 09 Call For Speakers

jcteague — Wed, 18 Feb 2009 01:51:46 GMT

When: May 30, 2009 – 8:30 AM – 5PM
Where: St. Edwards professional learning center, Austin, TX

The Austin .Net Users Group is hosting its fourth Code Camp. This one day, community driven conference has grown beyond the Austin community to a regional event with attendees from Texas, Louisiana, Arkansas & Oklahoma. Code Camp is for developers by developers, and we need you to help make this year’s event the best ever.

We are looking for presenters and session leaders to help educate the Austin .Net community and beyond. Sessions should be focus on software development practices and techniques that will have an immediate impact.

Session Length

To make sure that attendees get the most from your session, the length of the session will not be limited to one hour. Your session can be 1, 2, or 4 hours long. This gives you the freedom to dive deep into your subject matter and allow for discussion and dialog with attendees.

We encourage you to think outside of the traditional 1 hour presentation format and be creative with your presentation so that attendees have the opportunity to truly comprehend the topic.

Session formats

Code focused presentation – These are presentations that include both a little power point and a lot of code demos. Given the audience that is attending it is important that a large amount of the presentation is focused on code and coding related techniques.

Chalk Talks / Fish Bowl Discussions – These sessions are designed as a facilitated discussion around a developer topic. They are presented as a free form facilitated discussion that leverages the expertise of the presenter and the combined knowledge of the group to explore a specific topic.

Hands-on-labs – St. Edwards has a computer lab available at the facility, so this gives us the opportunity to explore a hands-on-lab option.

No Session Tracks

There will be no defined session tracks. Your topic can be on anything you think will interest .Net Developers (even if it’s not about .Net). Topics can include, but are not limited to:

General Development - This is a track that discusses general best practices for software development not tied to a specific application library or framework. Possible topics would be design patterns, testing strategies, specific language features (LINQ, generics).
Smart Client – This track is designed for topics related to Smart Client related development topics. This includes Windows Forms and Windows Presentation Framework applications, Microsoft Office or mobile devices.
Web Track – This track is designed for topics about Web based development that includes ASP.NET, MVC Framework, AJAX, and Web Services.
Project Management – This track is designed for presentations and chalk talks that include development process fundamentals and project planning activities such as size estimation, requirements gathering, etc.
User Experience -- Covers key disciplines that help bring users directly into your process and reap the rewards of effective, efficient and productive technology solutions, including UX Strategy, Usability Testing, Creative Design, Information Architecture and Design Technology.

Submission Deadline: April 17, 2009

Submit all sessions on the website http:// www.austincodecamp.com

Once your outline is received, we will review and provide scheduling for the selected sessions.

All slides and materials will be stored in the AustinCodeCamp09 google code website.

http://code.google.com/p/austincodecamp09/

Once we receive your submission, we will make grant you access to the repository. You must have a Google account to submit your materials.

The following information is required when submitting your session

Name:

Company:

Email:

Phone:

Website / Blog:

Session Length

Session Type:

Session Name:

Session Description:

Appendix A. - Code Camp Manifesto

(http://www.bostondotnet.org/CodeCamp/default.aspx/CodeCamp/CodeCamp%20Manifesto.html)

The original Code Camp was a conglomeration of ideas by many different people across the development community. The idea was simple provide an off hour forum for the development community to speak and share ideas for them to come and enjoy. The results have been astounding. I am happy to report that they are being planned across many different cities.

The question is what makes a Code Camp?

The answer is actually simple. In order to use the official Code Camp name and banner follow these simple protocols.

By and For the Developer Community

Code Camps are about the developer community at large. They are meant to be a place for developers to come and learn from their peers. Topics are always based on community interest and never determined by anyone other than the community.

Always Free

Code Camps are always free for attendees.

Community Developed Material

The success of the Code Camps is that they are based on community content. All content that is delivered is original. All presentation content must be provided completely (including code) without any restriction. If you have content you don't want to share or provide to attendees then the Code Camp is not the place for you.

No Fluff only Code

Code Camps are about showing the code. Refer to rule #1 if you have any questions on this.

Community Ownership

The most important element of the Code Camp is always the developer community. All are welcome to attend and speak and do so without expectation of payment or any other compensation other than their participation in the community.

Never occur during work hours

We need to understand that many times people can't leave work for a day or two to attend training or even seminars. The beauty of the Code Camp is that they always occur on weekends.

Another Way to Test Ajax Methods

jcteague — Tue, 10 Feb 2009 05:47:45 GMT

A while ago, Chad posted about how to test Ajax methods with QUnit. I’m also testing Ajax calls, but taking a different approach I thought I would share.

Chad’s approach was to put a timer in the test and waiting a while before performing the assertion. Another way is to hook into JQuery global ajax events, like the ajaxComplete event. Here’s some sample code that makes a call to the Flickr API via jsonp.

var url = "http://api.flickr.com/services/feeds/photos_public.gne?tags=austin,tx&format=json&jsoncallback=?";

$(document).ready(function(){
    test("should get results from getJson call",function(){
        expect(1);
        var results;
        $(document).ajaxComplete(function(){
            start();
            equals(results.title,"Recent Uploads tagged austin and tx","actual: " + results.title);
        });
        stop();
        $.getJSON(url,null,function(data){
            results = data;
        });
    })

});

Avoid Testing Ajax Calls in Unit Tests

Huh? You just showed me a way to do it, why should I avoid it? Making an Ajax call is just like making a database call, which should only be done for integration style tests. Just as you would stub a data repository method call in C#, you should do the same for AJAX calls. Except in JavaScript, this is 10 time easier because of it’s a dynamic, functional language. You can easily stub out method calls by replacing the method.

In this case I am testing against the title property, so I need a stub that looks like the getJSON method and returns back the title property.

Here is the same test, but with a stubbed out getJSON method.

var stubbedJSON = function(url,data,callback,format){
        callback({title:"fake results"});
    };
    var originalJSON = $.getJSON;
    module("stubbing out getJSON", {setup: function(){
        $.getJSON = stubbedJSON;
    }, teardown: function(){
      $.getJSON = originalJSON;  
    }})
    test("getJSON should be stubbed",function(){
        expect(1);
        $.getJSON(url,null,function(data){
            equals(data.title,"fake results");
        });
    });

One thing that I learned the hard way with QUnit tests is that whenever you stub a method, it stays stubbed for ALL of the test on the test page. To get around that, I store the original method in a variable, then reset the method manually in the teardown. This keeps my changes isolated for each test.

Now I’m able to test the logic of my JavaScript isolated from the data coming back from my data service. Notice how easy it was to stub out the method. No complicated mocking tool required. One you embrace the dynamic and the functional nature of JavaScript, you can do a lot more with the language than you expected. I’m appreciating JavaScript a lot more these days.

Austin Code Camp 09

jcteague — Tue, 10 Feb 2009 00:18:00 GMT

When: Saturday, May 30th

Where: St. Edwards Professional Education Center

We are gearing up for This Year’s Austin .Net User’s Group Code Camp. Last year we had 300 attendees and around 30 sessions. We expect this years to be even better. Register and submit sessions at www.austincodecamp.com (thanks Eric)

Encouraging Deeper Understanding of Content

In year’s past, we followed the traditional session 1 hour presentation format used by most conferences. As I’ve attended and speak more conferences, I am finding the one hour session both hindering my ability to adequately learn anything and my ability to deliver quality information. So this year we are doing something a little different. Sessions will not be limited to one hour!!! Sessions will be 1,2,4 or 6 hours long. Hopefully this will allow you to better comprehend the information being presented instead of being bombarded with new concepts

You can contact me or Eric Hexter if you have any questions.

See you there!!!

Please rebroadcast this message as loudly as possible!!

What is CodeCamp

http://www.bostondotnet.org/CodeCamp/default.aspx/CodeCamp/CodeCamp%20Manifesto.html

By and For the Developer Community

Always Free

Code Camps are always free for attendees.

Community Developed Material

No Fluff only Code

Code Camps are about showing the code. Refer to rule #1 if you have any questions on this.

Community Ownership

Never occur during work hours

We need to understand that many times people can't leave work for a day or two to attend training or even seminars. The beauty of the Code Camp is that they always occur on weekends.

Google’s Testers take on Dependency Injection

jcteague — Wed, 21 Jan 2009 00:27:11 GMT

If you’re not already subscribing to the Google Testing Blog, you should be. There are some really interesting articles on it. The latest one takes on if and when to use Dependency Injection. I agree with their answer: yes and always!

PTOM: Bend 3rd Party Libraries to Your Will With the Adapter Pattern

jcteague — Tue, 25 Nov 2008 05:43:00 GMT

No matter what you do or where you work, there will always be the 3rd party library that your manager insists you use (you know, the one whose agreement was made on the golf course), or that old legacy code that is impossible to test. Now it might be easy to just throw your hands up in desperation, but you can shield your code from this big ugly untestable tangle by hiding it so that you will never know you are using the library. The easiest way is to use the Adapter Pattern.

The definition of the adapter pattern, from c2.com is:

Convert the interface of some class b into an interface a that some client class c understands.

Now this is definitely a very useful ability of this pattern, and can solve some problems very elegantly. One area where I used this pattern with this strict definition was to convert messages from one logging framework to another. But there is really much more potential behind this rather diminutive definition. It allows you to hide whatever you want behind your own interface and only have to slay those 3rd party or legacy code dragons in one place. Now the rest of your application go along it’s merrily way.

Here is the UML for the Adapter pattern.

I got to be honest, generic class diagrams do me almost know good. I’m just not one of those visual learners I guess. Here’s what the code structure looks like.

public class ThereBeDragonsHere{
    public int AMethodINeedToCallButCannotTest(xxx)
}

public interface IHideDragons{
    WhatTheIntReallyMeans CallMeInsteadOfUglyOne(xxx);
}

public class DragonHider : IHideDragons{
    private ThereBeDragonsHere _dragons;
    
    public DragonHider(Dependency dep){
        _dragons = new ThereBeDragonsHere();
        setupDragon(dep);
    }
    public WhatTheIntReallyMeans CallMeInsteadOfUglyOne(xxx){
        var answer = _dragons.AMethodINeedToCallButCannotTest(xxx);
        return correctTheAnswer(answer);
         
    }
    
}

Now the dragons are safely hidden. What’s more, you can transform the messages passed back and forth to the 3rd party library in whatever terminology that correctly defines the conversation in terms of your application. The rest of the application is now testable, mocking out your object when you need to.

In the online open meeting last week, someone asked how do you introduce testing into a legacy codebase. In this case, the speaker said that in order to introduce TDD into an app, he needed to change about 30 classes and was unsure about the implications of the changes as well as the scope creep it put on his time estimate. This is one way to introduce TDD into a code base is one technique that can help you get there. Through continuous improvement, you will have a system that is testable and maintainable.

John Teague's Blog

Giving Your MVC Views an Identity

Programming Basics: The for loop can do more than increment an integer

Ruby and Rake as an executable

Austin Code Camp Schedule

Submit Your Austin Code Camp Sessions Now

Building Maintainable Web Applications Training Course

Resharper templates: Don't forget the Macros

Cooking With Pablo: Chicken Cacciatore

Ingredients

Variations

The MVC Template Team Got It Right

Polymorphism with JavaScript

Austin Code Camp 09 Call For Speakers

When: May 30, 2009 – 8:30 AM – 5PM Where: St. Edwards professional learning center, Austin, TX

Session Length

Session formats

No Session Tracks

Submission Deadline: April 17, 2009

The question is what makes a Code Camp?

By and For the Developer Community

Always Free

Community Developed Material

No Fluff only Code

Community Ownership

Never occur during work hours

Another Way to Test Ajax Methods

Avoid Testing Ajax Calls in Unit Tests

Austin Code Camp 09

When: Saturday, May 30th

Where: St. Edwards Professional Education Center

Encouraging Deeper Understanding of Content

What is CodeCamp

By and For the Developer Community

Always Free

Community Developed Material

No Fluff only Code

Community Ownership

Never occur during work hours

Google’s Testers take on Dependency Injection

PTOM: Bend 3rd Party Libraries to Your Will With the Adapter Pattern

When: May 30, 2009 – 8:30 AM – 5PM
Where: St. Edwards professional learning center, Austin, TX