John Teague's Blog

Implementing Domain Queries

jcteague — Sat, 30 Jan 2010 05:48:23 GMT

My current Repository interface looks something like this:

public interface IRepository
    {
        T FindOne<T>(int id);
        T FindBy<T>(Expression<Func<T, bool>> expression);
        IEnumerable<T> FindAllBy<T>(Expression<Func<T, bool>> expression);
        IEnumerable<T> FindAll<T>();
        T FindOneBy<T>(Expression<Func<T, bool>> expression);
        void Save<T>(T target);
        void Update<T>(T target);
        void SaveOrUpdate<T>(T target);
        void Delete<T>(T target);
        IEnumerable<T> Query<T>(Expression<Func<T, bool>> expression);
    }

It’s modeled after the Repository class that Jeremy and Chad put in the early versions in Fluent NHibernate (now removed). It relies almost completely on Linq expressions for where statements, which make queries very easy to write and understand. Like this one:

_repository.FindBy<User>(user => user.Enabled == true);

This works great for small where statements, but when you need more control over the query, the current implementation doesn’t really allow you to fully take advantage of NHibernate or the Linq provider. Another downside is your code is not really DRY when you have small where statements littered everywhere.

So to solve these problems I implemented a very simple Domain Query pattern. Domain Queries are classes that encapsulate complicated or common queries into self contained objects that can be reused throughout your application. I had some very simple goals for this implementation:

Keep it simple to access from the executing code.
I wanted full access to all of Nhibernate’s functionality when I needed it.
Keep it testable.

So Let’s start with the end and then show the beginning. I wanted it really simple to access a domain query. This is what I had in mind for executing a domain query:

_repostiory.FindAll(Queries.GetAllActiveUsers());

To get there I started with a really simple interface. Because there were two basic queries I wanted to execute: return a single object or a collection of an object (I don’t have a use case for things like GetScalar yet) I need two methods on my interface:

public interface IDomainQuery<T>
{
   T ExecuteUniqueResult(ISession session);
   IEnumerable<T> ExecuteList(ISession session);
}

I then added the following methods to my Repository:

public T FindOne<T>(IDomainQuery<T> query)
{
    return query.ExecuteUniqueResult(Session);
}
public IEnumerable<T> Query<T>(IDomainQuery<T> query)
{
    return query.ExecuteList(Session);
}

My repository is responsible for knowing how to access the session. Passing the ISession object to the domain query helps me meet two of my goals, I have full access to everything on the session and it is easy to test my domain queries since they are not responsible for managing the Unit of Work. I can create different UoW contexts in my application and my integration tests.

To create the domain queries, I use the Template pattern to abstract the IDomainQuery aspects and allow the concrete classes only deal with the query construction. I have two abstract classes right now: LinqDomainQuery and CriteriaDomainQuery. It’s pretty obvious what each of these do. The CriteriaDomainQuery utilizes the DetachedCriteria functionality. The LinqDomainQuery obviously utilizes the Linq provider. I could easily create an HQLDomainQuery and an SQLDomainQuery as well, but following YAGNI I don’t need them yet. Here is the LinqDomainQuery:

public abstract class LinqDomainQuery<TResult> : IDomainQuery<TResult>
{
    protected abstract IQueryable<TResult> GetQuery(ISession session);
    public TResult ExecuteUniqueResult(ISession session)
    {
        return GetQuery(session).SingleOrDefault();
    }
    public IEnumerable<TResult> ExecuteList(ISession session)
    {
        return GetQuery(session).ToList();
    }
}

Some important things to Note: Notice that I call the SingleOrDefault() and ToList() methods. This keeps me from having deferred execution bugs crop up. I had some issues during testing because I was closing the session faster than I was actually executing the query. Doing that here prevented that from happening. Also notice that it the generic type is TResult. With the Select statement, you can perform projections very easily. I can return DTO data directly from the query, giving me precisely the SQL statement I need and no need to map between complicated Entities to flattened DTOS.

Here is an example of selecting a DTO from a Linq Query:

public class LoadBuilderDataQuery : LinqDomainQuery<LoadBuilderData>
{
    private readonly int _page;
    private readonly int _rows;
    public LoadBuilderDataQuery(int page, int rows)
    {
        _page = page;
        _rows = rows;
    }
    protected override IQueryable<LoadBuilderData> GetQuery(ISession session)
    {
        return
            session.Linq<OrderTicket>()
                .Skip(_page*_rows).Take(_rows)
                .Select(t => new LoadBuilderData()
                                 {
                                     LoadId = t.Id,
                                     PromisedDate = t.PromisedDate,
                                     Address = t.Destination.Address1,
                                     City = t.Destination.City,
                                     State = t.Destination.State,
                                     Zip = t.Destination.Zip,
                                     CustomerName = t.Order.Customer.CustomerName,
                                     StoreNumber = t.FulfillingStore.StoreNumber,
                                     OrderNumber = t.Order.OrderNumber,
                                     OrderSuffix = t.OrderSuffix
                                 });

I have fully tested this query as well. Here is an example, I’m leaving some of the setup and UoW handling out for brevity, you can get the idea.

//do some setup in the base class
public class when_retrieving_first_result_set : LoadBuilderQueryTests
{
    //unit of work helper opens and closes the session for me
    private Because of =
        () => result = UnitOfWorkHelper.Use(session => new LoadBuilderDataQuery(0, 10).ExecuteList(session));
    private It should_return_10_rows = () => result.ToArray().Length.Should().Equal(10);
    private It should_return_LoadBuilderData =
        () => result.ToArray()[0].Should().Be.OfType(typeof (LoadBuilderData));
}

Here is the SQL Query generated:

Now back to the beginning. To reduce some of the complexity of calling these classes, I wrapped then in static methods to make them easier to call:

public class Queries
{
    public static IDomainQuery<LoadBuilderData> GetLoadBuilderData(int page, int row)
    {
       return new LoadBuilderDataQuery([page, row);
    }
}

This is just some syntactic sugar, but small things like that keep your application easy to read and understand.

This is a very simple way to implement domain queries. You can go a lot further with this. Tim Scott took my simple approach and really took the training wheels off. If I can’t get him to post about it it will.

Brown Bag It To Pablo’s Fiesta

jcteague — Fri, 29 Jan 2010 15:11:00 GMT

Thanks to the generous folks, at St. Edwards PEC, the only real cost to organizing our Open Space conference is providing food. This what the $15 registration fee is covering: food, drinks and snacks.

It’s important to us that whoever wants to attend shouldn’t have to sign corporate expense requests in triplicate and I hope that a $15 registration fee isn’t keeping you from coming.

But, if you’re like me and really like free or you really don’t like conference food, here is a discount code that waives the registration fee.

http://pablofiesta09.eventbrite.com?discount=no-food

This discount waives the registration fee and we will not reserve you lunch (we may have extra, but don’t count on it). BTW, lunch will be a box lunch with a sandwich & chips.

If you have already registered and would like to use this discount just let me know and I’ll give you a refund.

Remember we are capping registration at 150 and we have passed the 90 mark for registered attendees. It is shaping up to be a great time. Please come an join us.

(funny I just realized that it isn’t 09 anymore)

And Now a Word From Our Sponsors

jcteague — Wed, 06 Jan 2010 23:33:43 GMT

I wanted to take a moment and thank the sponsors of Pablo’s fiesta open space conference. People and Organizations who sponsor conferences do so because they value their community and use base. This is especially so for open space conferences since there are very few “formal” presentations with PowerPoint slides and product demos. We have been very lucky to have a lot support from the Friends of Pablo other companies to keep the cost low enough so the ticket price is not a barrier to attend.

St. Edward’s Professional Education Center

St. Ed’s PEC has been a great partner for several events in the Austin area. They have graciously have donated the space for the conference. Without this donation the ticket cost would be dramatically higher.

Microsoft

Say what you want for MS, but they have been a great sponsor of community events. They have helped us with the Austin Code Camp’s and Pablo’s Day of TDD. It’s nice to have a reliable partner for doing events that are targets community education. Our developer evangelist, Phil Wheat had been very supportive our efforts.

Other Sponsors

McLane Advanced Technologies will be providing drinks and snacks for everyone
Pragmatic Bookshelf will be providing some books
The Lounge provided advertising
Infragistics
Avenida Software (Me)
Independent Software Fabrication (Gregory Long Linkedin)

The Conference is coming together really well. 75 people have registered. We are limiting space to 150, so if you are waiting to the last moment, you might want to speed that up.

The Open Space Conference Experience

jcteague — Wed, 16 Dec 2009 05:30:32 GMT

he Los Techies Fiesta is shaping up to be a wonderful conference. We’ve had excellent response with more than 60 people register and quite a few sponsors to help make it even better. I thought I would take a moment and talk about what it's like attending and open space conference. These are, of course, my experiences and one thing about an Open Space conference is that everyone’s experience will be different.

If you want to learn more, visit the Open Space wiki to get much better description.

The Break Room Effect*

If you have ever gone to a conference and had the most amazing, eye opening discussion in the break room between sessions, this is what an OS conference is all day. It is more about a conversation amongst peers than presentational training (although there could be some of those too). Most sessions will be ad-hoc conversations

*I know I stole that line from somewhere, but couldn’t find it again to reference it

The Schedule

We’ll be following the same schedule that I’ve seen at the few I have been too. I can’t go into too much detail since I will not be the facilitator. I’d rather give too little information than incorrect. On Friday we’ll have our opening session where we’ll nominate and vote for topics we find interesting and would like to discuss. On Saturday we’ll have our breakout session. As per one of the tenants of Open Space, it’s over when it’s over, there is no timeline for a given topic. we’ll have spillover rooms setup for conversations that need to continue. Then on Sunday we’ll have a few wrap up sessions and then close.

Transformational

I feel that these conferences are a truly transformational event. Compared traditional conferences where I might learn a lot and (and then quickly forget as I don’t use the knowledge at work), OS conferences offer a chance to really connect with the community and work towards improving myself and the community.

If you haven’t already registered I hope you will. It is going to be a very fun time and I look forward to meeting everyone who does come.

Pablo’s Fiesta: Open Space Conference in Austin TX

jcteague — Mon, 16 Nov 2009 21:36:27 GMT

Pablo's Fiesta

Los Techies Open Space Conference on Software Quality & Craftsmanship

When: February 26, 27 & 28
Where: St. Edward's Professional Educational Center, Austin TX

I am proud to announce the first Los Techies Open Space Conference. We’ve been working on this for a while we are now finally ready to make the public announcement.

You can see all of the details and register here.

What I want the conference to be.

The great thing about Open Space conferences is that the content as well as the tenor of the conference is defined more by those attending than those who organize it. Here is what I think the conference should be.

The topic of the conference will be focused on Software Quality and Craftsmanship. This is a topic that is very near and dear to the hearts of the Los Techies crew. Quality is the most important feature of any product, and can be difficult to achieve and measure in software. Craftsmanship is a philosophy about how professionals in our field should approach their work and how, as a profession, we should focus on cultivating a community of software developers who learn, respect and give back to the profession.

There are several important aspects to being a craftsman that I to address:

Sharpening the Saw. It important to learn new techniques and different technologies to continue to grow in this profession. I’m the software developer equivalent of a gear head (or petro head you you UK guys). I have no doubt there will be some technical discussions.

Multi-Platform. I want to talk about more the C#. Let’s discuss iPhone, Ruby, Python and any other platform that help us become better software developers.

Selling Quality as a feature. How do we convince clients and business executives that quality is a feature of software that has a very big impact on their bottom line.

Come to the conference and influence help shape it to be to what you think it should be. Please join us in Austin TX, February 26,l 27 & 28.

Making JavaScript APIs Easier to Use

jcteague — Wed, 16 Sep 2009 04:21:00 GMT

Todd Anglin presented some of the AJAX functionality available in ASP.Net 4.0 at this months ADNUG meeting. One of the things he demonstrated was the Client Side binding, which is really cool (I’ll have more on this later). In one of his code samples, he showed how the MS AJAX library call to bind an element to a datasource. It looked odd to me at first and and I couldn’t figure out why at first. Then on the way home, I realized that it designed completely wrong for a JavaScript function. The function call looked something like this (I may not get this syntax completely right,it’s just an example, please don’t sweat the details).

  $create(Sys.Data.DataView, {}, {}, $get('identifier'));

It’s a fairly simple method call. I haven’t studied the details, so I don’t know exactly what all of the parameters do. It looks like the first parameter is the data type, the second and third are a set of options we don’t need in this example, and the last parameter is the id of the element we want to databind. So what is wrong with this? I am needing to declare a lot of function parameters I don’t need for normal operations. It looks like an overload with just the element to databind would be what I would use for common usage.

One of the cool parts in JavaScript is that I don’t need to actually overload the method. I can call the method with just the first paramter and the others will be null. I can deal with this possibility be creating aliases that have default values if they are null. The shortcut syntax looks like this.

  function create(element, datatype, options1, options2) {
     var dt = datatype || Sys.Data.DataView;
     var op1 = options1 || {};
     var op2 = options2 || {};
     //do something with variables now
   
   }

What this code is doing is setting the private variables to default values when the parameters are null.

Now I could use the function like this and get the same results:

  $create($get('identifier'));

I could go further and make it even easier to on the developer by testing to see if the element is either a string or an object .

  function create(element, datatype, options1, options2) {
     var dt = datatype || Sys.Data.DataView;
     var op1 = options1 || {};
     var op2 = options2 || {};
     var el = typeof (element) === 'string' ? $get(element) : element;
     //do something with variables now
   
   }

Now I could also use the method like this, even further reducing my cognitive load

  $create('identifier');

JavaScript has tons of little features like these that can make really fun to use when the API designers take full advantage of what it has to offer. Of course it does have it’s share of “bad” features too. A great API is one that knows the differences.

JQuery Does Not Like QuirksMode

jcteague — Tue, 15 Sep 2009 03:21:26 GMT

I was helping a client out today with a JQuery issue. They were well into the development of an applications that heavily uses the JQuery UI dialog widget to show information. Like most web developers they were using Firefox/Firebug for day-to-day development (because trying to develop complicated apps with IE is painful). All of their dialog windows were working normally with an acceptable load time.

However, when they started testing in IE, the dialogs screens were painfully slow. Less than a second in Firefox was now 4+ seconds on IE. We stripped it down to just a simple dialog, do nothing but displaying a div with some text and still taking a long time. At this point I knew it was something inside JQuery that was causing it. I didn’t think it was a bug because I’ve used them plenty of times cross browser with not problems. The team further drilled into the jQuery code that was taking so long using a profiler. There was some code that looked like this (not all of it)

  return this[0] == window ?
             // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
             document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] ||
             document.body[ "client" + name ] :

document.CompatMode returns two values: “CSS1Compat” when in compatibility mode and “BackCompat” when in quirks mode.

So, jQuery does something different in quirksmode than compatibility mode. A quick check determined the page was being rendered in quirks mode, which forced jQuery to use some less than optimal approaches to modifying the dome elements. I always knew this was the case, but I didn’t expect it to be 4 seconds of difference!!

This can be avoided by specifying the DOCTYPE for your pages. Apparently the team did look into this, but they had a comment before the doctype declaration and it must be the first line or it will be ignored by the browser, guaranteeing quirks mode in IE.

I’m sure that jQuery makes this type of check all over the place, so if you are targeting Internet Explorer I would stay in compatibility mode.

Testing Private & Protected Members of a Class

jcteague — Fri, 28 Aug 2009 04:48:39 GMT

In my last blog post, someone asked me you can write unit tests for a private or protected method. I gave part of the response in a comment, but I need to give a more detailed description.

Focus on the public API of your system

First and foremost, I focus on testing the public API. You should be able to test all of the code branches in your private methods by adequately testing the public methods in your system. Using tools like NCover can help you analyze how well your tests are actually testing your system. I don’t try to get 100% coverage, but I typically have above 80% as a normal target.

Testing Protected Members

There are times when you do need to test protected members of a class. If you are inheriting from a class that you do have the source code to (like say Controller) and you override a protected method, it is possible to test that. While it should be possible to test protected member through the public api, it is relatively simple to do it and doesn’t really break any encapsulation rules in your application.

It is actually very easy. All you need to do is create a test class that inherits from you and add a public method that call the protected method in question. Here is an example.

  public class ClassWithProtectedMember
     {
         protected int UltimateQuestionAnswer() { return 42; }
     }
 
     public class ProtectedMemberAccessor : ClassWithProtectedMember
     {
         public int ExecuteUltimateQuestionAnswer(){
             return base.UltimateQuestionAnswer();}
     }
     [TestFixture]
     public class ProtectedMemberSpecs {
 
         [Test]
         public void should_give_us_the_answer_to_life_universe_and_everything()
         {
             var wrapper = new ProtectedMemberAccessor();
             Assert.That(wrapper.ExecuteUltimateQuestionAnswer(),Is.EqualTo(42));
         }
     \

This is a very simple and straightforward approach, but is very effective in testing some hidden members in you system.

The TryThis method

jcteague — Thu, 27 Aug 2009 04:19:27 GMT

The more I learn and use dynamic languages like JavaScript and Ruby, the more I feel the constraints placed on me by the C# compiler. Today I needed to wrap a bunch of calls to a web service facade in some try catch statements. I really hated the idea of littering my code with these because a lot them make the code that much harder to read. What I really wanted was a method that would execute the statement in a try/catch and do the necessary exception handling for me. In this situation, the method calls were very different (number of parameters, return values), but the error handling was exactly the same.

What I really wanted was something like the block statement in Ruby, where I just pass in arbitrary code to a method that would then execute it. It was a little trickier in C# because of the variations in the method signture. A method that had a Func parameter wouldn’t work because I had varying number of parameters. Also the changing return value added a nice twist. In the end, it came out rather nice.

With this little method I can now pass in any method and

   private bool TryThis(Action block)
         {
             try
             {
                 block();
                 return true;
             }
             catch(Exception)
             {
                 //do something with exception here
                 return false;
             }
         \

Here are a few tests to show what it looks like.

  public interface Foo
     {
         DateTime Bar(string a, string b);
         string Bar2(int a);
         void Bar3(int a, int b);
     }
     [TestFixture]
     public class trythis_specs
     {
         private Foo mock;
 
         [SetUp]
         public void setup()
         {
             mock = MockRepository.GenerateMock<Foo>();
         }
        [Test]
        public void should_return_true_when_there_is_no_exception()
        {
            mock.Stub(m => m.Bar("a", "b")).Return(DateTime.Now);
            DateTime output;
            bool result = TryThis(() => output = mock.Bar("a", "b"));
            Assert.That(result);
 
        }
        [Test]
         public void can_get_the_value_from_executing_method()
        {
            var time = DateTime.Now;
            mock.Stub(m => m.Bar("a", "b")).Return(time);
            DateTime output = DateTime.MinValue;
            bool result = TryThis(() => output = mock.Bar("a", "b"));
            Assert.That(output, Is.EqualTo(time));
        }
        [Test]
         public void return_false_on_exception()
         {
            mock.Stub(m => m.Bar3(1,2)).Throw(new Exception());
            var result = TryThis(() => mock.Bar3(1,2));
            Assert.That(result, Is.False);
         \

That’s not quite as clean a block parameter in Ruby, but I can live with it for now.

Wiring Up Generics In Castle Windsor

jcteague — Thu, 20 Aug 2009 20:49:00 GMT

I'm working with a new team that has a slightly different technology stack then I'm used to. On most projects where I am the team lead, StructureMap is my IOC container of choice. I've always thought that this was just laziness on my part because I can wire up most things very quickly. Now I'm beginning to think that SM has spoiled me :)

I like to take advantage of open generic mapping that most of the popular containers support. In this particular case, I've got a Generic Validator that takes in a different array of validations for a given type.

The constructor for this guy looks like this:

public class ServiceValidationRunner<T> : IServiceValidationRunner<T>
    {
        private IValidation<T>[] _validations;
        private readonly IValidationErrorHandler _errorHandler;

        public ServiceValidationRunner(IValidation<T>[] validations, IValidationErrorHandler errorHandler)
        {
            _validations = validations;
            _errorHandler = errorHandler;
        }
       ...
}

Here is how I'm am setting this up for two different types that have different validations:

container.Register
            (
                //wire up the specific types with their validation rules
                Component.For<IServiceValidationRunner<Object1>>().ImplementedBy<ServiceValidationRunner<Object1>>()
                    .DependsOn(new {validations = new[]{new Validator1(),new Validator2}}),
                Component.For<IServiceValidationRunner<Object2>>().ImplementedBy<ServiceValidationRunner<Object2>>()
                    .DependsOn(new {validations = new[]{new Validator1(), new Validator3()}}),
            ...
);

The code is pretty self explanatory, it's a simple matter of wiring up the dependencies for the specific type the generic class is wired up for.

Demeter Helps You Fend Off the One True Constant: Change

jcteague — Mon, 20 Jul 2009 04:33:00 GMT

There have been some good discussion lately around the Law of Demeter. The worst thing about Law of Demeter is that it has the word “Law” in it. Like all of the SOLID principles, it should be considered a rule of thumb and your experience and knowledge of the domain should tell you when it it appropriate. However, I would consider staying consistent with this principles (as with all of the others) the starting point and transgress only under special circumstances.

If you haven’t heard of Demeter, the formal definition is that methods of a given class should only access:

Fields and Methods on the object.
Any object created within the method.
Any direct properties or methods of an argument to the method

By following Demeter, you have stronger encapsulation in your objects. This will lead to fewer coupling points in your application and thereby lowering coupling in your system. When you do violate this principle it is easy to get into the situation where a change in one part of system has repercussions in other parts that were not touched for a specific release. That’s when your day after release becomes a nightmare of chasing down bugs in production you can’t explain.

Recently I was was brought on to a very large application that has been in development for over a year. When pairing with one the devs on a new feature, the implementation he proposed broke Demeter in several places, accessing child properties and methods a few levels deep. When I brought this to his attention and explained to him that if you’re absolutely sure the object in question will always be created with the Properties in question, then you can considerate an allowable break of the rule.

The developer I was partnering did not think it was possible to construct the object in which this violation would ever cause a problem. He’s a smart guy and I have no reason to doubt him, but as the title of of this post states, change is the one true constant. We know that requirements change over time. We also know that end users are very creative in using applications for solving problems they are not designed for.

Staying consistent with Demeter is my default way of developing new features. Even if I think the chances of getting into an invalid state are infinitesimal, I still try to stay consistent with this principle. It gives me greater flexibility to change the system as necessary and keeps my dependencies to getting to “sticky”, where I have to worry about who is accessing a property inappropriately when it is time to change them.

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.