Testing if a nullable boolean is true is quite simple in C#, there are many ways, sorted here in my preference order.

bool? nullableBool = true;
var option1 = nullableBool == true;
var option2 = nullableBool.Equals(true)
var option3 = nullableBool.HasValue && nullableBool.Value;
var option4 = nullableBool ?? false;

All options return true in this case, false for nullableBool = false; and also false for nullableBool = null;

However, when using this expressions is labmdas inside a LINQ to SQL projection they will behave differently! LINQ to SQL it is not smart enough to translate to T-SQL in a way that the current ANSI_NULLS setting does not affect the query result. To avoid NULL = 1 comparisons, don’t use option1 or option2 there!

Huh? Please elaborate

Consider a table in Microsoft SQL Server, with a nullable bit column, like this

CREATE TABLE [dbo].[Banana] (
 [Id] INT,
 [IsYellow] bit NULL,
)

I will not get into whether you should have bit NULL columns or not (you probably shouldn’t) but if you do, and you are using LINQ to SQL to query your RDBMS, your generated Banana entity will have an IsYellow property, of  bool? C#type. Makes sense!

The following simplified code, though a little bit pointless in this case, is a perfectly valid situation if you wanted to avoid a nullable in your DTO, or you are projecting a boolean for any other reason.

ctx.Bananas.Select(x => new 
                      { 
                          Id = x.Id,
                          IsYellow = x.IsYellow == true
                      });

… but it will generate the following ANSI_NULL OFF dependent T-SQL code:

SELECT [t0].[Id], 
    (CASE 
        WHEN [t0].[IsYellow] = @p0 THEN 1
        WHEN NOT ([t0].[IsYellow] = @p0) THEN 0
        ELSE NULL
     END) AS [IsYellow]
FROM [Banana] AS [t0]

If there are any rows with NULL IsYelow, this code will will generate an “InvalidOperationException: The null value cannot be assigned to a member with type System.Boolean which is a non-nullable value type.” This happens because the  CASE will fall through the ELSE clause for any NULL value, thus returning a NULL in the result set, unasignable to our regular non-nullable boolean.

Note that the condition [t0].[IsYellow] = @p0, where @p0 is true and [IsYellow] is NULL, is neither true nor false according to the SQL 92 standard, this is the behavior when  ANSI_NULLS are are set to ON, wich is the default and will be actually forced ON in next versions of the MS SQL Server.

The last option will work as expected. For example:

ctx.Bananas.Select(x => new 
                      { 
                          Id = x.Id,
                          IsYellow = x.IsYellow ?? false
                      });

Would generate a safer NULL checking T-SQL code, like:

SELECT [t0].[Id], COALESCE([t0].[IsYellow],@p0) AS [IsYellow]
FROM [Banana] AS [t0]

You may also want to read:

• The SET ANSI_NULLS Reference in the MSDN

… a meeting where a bunch of coders get together to work on a programming challenge. They are there have fun and to engage in Deliberate Practice in order to improve their skills.

And it works. It’s an amazing way to learn and reinforce best practices, and to share.

If you have not yet, go search when is the next coding dojo in your community, or organize yours!

Not only individuals and interactions,
but also a community of professionals.

 

Fluent!

FluentAssertions allows us to convert something like this:

[Test]
public void ReturnsYellowForBananas()
{
    var service = new FruitColorService();
 
    var result = service.GetColorOf(new Banana());
 
    Assert.AreEqual(Color.Yellow, result);
}

Into something like this:

[Test]
public void ReturnsYellowForBananas()
{
    var service = new FruitColorService();
 
    var result = service.GetColorOf(new Banana());
 
    result.Should().Be(Color.Yellow);
}

Exception checking

It also allows for this kind of exception checking (here using the Microsoft.Visual.Studio. UnitTesting namespace instead of NUnit like in the previous examples):

[TestMethod()]
[ExpectedException(typeof(InvalidFruitException))]
public void ThrowsAnExceptionIfItIsNotAFruit()
{
    var service = new FruitColorService();
 
    var result = service.GetColorOf(new Tomato());
}

To become the following snippet. I preffer this way because it keeps the arrange, act, assert form:

[TestMethod()]
public void ThrowsAnExceptionIfItIsNotAFruit()
{
    var service = new FruitColorService();
 
    Action action = () => service.GetColorOf(new Tomato());
 
    action.ShouldThrow<InvalidFruitException>();
}

I preffer the FluentAssertions way, but note that NUnit also has it’s fluent API for this purpose, using Assert.That in this case. the last two lines would become:

TestDelegate test = () => service.GetColorOf(new Tomato());
 
Assert.That(test, Throws.Exception
      .TypeOf<InvalidFruitException>());

When something goes wrong

In contrast to the Microsoft TestTools.Assert, both FluentAssertions and NUnit try hard to make the error message as clear as possible, when a test fails you certainly want to know what is happening and not just that it broke plus a meaningless line number. This is true specially if you are not on the IDE where you can just click-and-go to the ofending test, but reading a report from your continuous integration server. For the second test in this post, FluentAssertions would print out something like:

Expected object to be Color [Yellow], but found Color [Green].

Much more

FluentAssertions has lots of usseful methods to work with DateTime, TimeSpan, Collections, String, etc. It became an essential tool in my everyday work, if you are into C#, give it a try!

Nice badge to add to the collection of trophies (and yes, I did scramble the QR)

I’m also thankful to the people at Diaz & Hilterscheid who organized the event, Madeleine Griep! who we drove crazy with changes in the hotel reservation many times, Uwe Gelfert, José Díaz, and the @AgileTD team.

I had the chance to personally meet Lisa Crispin and Gojko Adzic on the speaker’s dinner and during the conference. Lisa is one of the authors of the book Agile Testing, we also had the honor of having her at the front row in our talk! It’s good to put faces to the books we read :-)

Test Lab Rats

From the left: Iván Stepaniuk, James Lyndsay, Carlos Blé, Bart Knaack.

James Lyndsay and Bart Knaack where on the TestLab, an amazing corner of the conference, totally hands-on where developers and testers shared their skills. Being a developer, it was really interesting to understand how professional testers work, sit with them and pair-test an application from a black-box perspective.  We also spent some time testing LiveTeamApp, a team time management application developed using the BDD techniques for JavaScript we talked about in this conference.

It was a really intensive experience and there are still ideas and notes to go through, and lots of new people to stay in touch with.

The call for papers for the next year is about to start, I hope to be there in 2013!

You may also want to read:

• Carlos Blé post: Agile Testing Days 2012 was awesome
• Ralph Jocham post: Agile Testing Days 2012 – Take Away 
• The conference program
• Xu Yi: http://letagilefly.com/post/2012/12/agile-testing-days-2012-takeaways-9249.html (From where i’ve stolen some of this links!) :-)
• Sigge Birgisson: http://happytesting.wordpress.com/2012/11/29/learnings-from-agile-testing-days-2012/
• Huib Schoots: http://www.huibschoots.nl/wordpress/?page_id=297
• Reinder: http://reinderotter.blogspot.fi/2012/11/pink-fluffy-unicorns-agile-testing-days.html
• Augusto Evangelisti: http://mysoftwarequality.wordpress.com/2012/11/24/did-we-get-it-all-wrong/
• Serendipeddy: http://www.serendipeddy.nl/agiletd2012/
• Anne: http://herebesubtlety.squarespace.com/blog/2012/11/28/conference-tweeting-or-what-is-up-with-that.html
• Chris George: http://www.simple-talk.com/blogs/2012/12/04/agile-testing-days-2012-my-first-conference/

SELECT AVG(Rating) AS AvgRating FROM CarRating;

Doing this in LINQ to SQL is quite trivial; The Average method returns the average from the numeric sequence:

 var avgRating = Ctx.CarRatings.Select(x => x.Rating).Average();

The problem:

In the following example, we select an additional aggregate to get the maximum value of the whole Rating column in addition to the average:

SELECT AVG(Rating) AS Average, MAX(Rating) AS Maximum FROM CarRating;

In this case however, writing a LINQ to SQL equivalent is not that easy, one option would be splitting the query in two LINQ sentences. This is the most readable way to express what we want (and I like that), but hits the database twice and in some circumstances, specially if your table is big, you may not be able to live with that.

var avgRating = Ctx.CarRatings.Select(x => x.Rating).Average();
var maxRating = Ctx.CarRatings.Select(x => x.Rating).Max();
// Voila

The hack:

I refused to believe that there is no -good- way to express this simple SQL sentence in LINQ to SQL without hitting the DB twice. The only solution I have found so far, and the intertubes seem to agree, is to use a group by clause in the sentence. You would say; group by what? Well… that’s exactly the problem, it does not really make any sense, but if you group by a constant (!)…

var ratings = Ctx.CarRatings
                 .GroupBy(uselessConstant => 0)
                 .Select(r => new
                    { 
                      Avg = r.Average(x => x.Rating),
                      Max = r.Max(x => x.Rating)
                    })
                 .FirstOrDefault();
// Voila (WTF!)

This works, but remember that good code is readable code, naming the .GroupBy() lambda with something horrible like uselessConstantThatAllowsSelectingTwo-AggregateColumnsWithoutHittingTheDbTwice, is better that breaking the WTF-o-meter in a code-review or future maintenance. A comment may also be opportune in this case, perhaps even a link to this post ;)

Any comments or thoughts are welcome! Specially if you have a better way to solve this.

What about Hijax?

This problem is not new; almost a decade ago, when JavaScript availability in the browser was something you could not rely on, an AJAX loaded content section would gracefully degrade and load as complete page if no JavaScript was at work, effectively solving the search engine problem a well. This technique was later called Hijax, and it requires your backend to be able to generate a full HTML version of what would have been otherwise rendered/composed on the browser.

If most of the HTML content is generated with the server-side tech (like in ASP.NET or PHP) I would still consider Hijax as an alternative, but if the content that you want indexed is served as JSON, XML, etc. and it never takes an HTML form until it is in the DOM, a hybrid Hijax-style solution would be expensive and complicated, let alone the case of using client-side templating engines like mustache, dust.js, handlebars, etc. This later case is the one we will talk about.

The crawler requests

Nowadays you can count that JavaScript will be there for you when the user loads the site, but what about the search engine crawlers? Fortunately, in 2009 Google defined a standard, which latter Bing (and thus Yahoo) also supported in 2011. It basically defines a bidirectional mapping that is applied to every URL containing #!, allowing a link to:

example.com/profile#!/jdoe

To become a GET request for:

example.com/profile?_escaped_fragment_=%2fjdoe

That new URL is what the crawler will actually request when encountering and following a link with ‘#!’ in the anchor fragment.  This solves an important part of the problem, but we still need to generate an HTML snapshot for the crawler to download, parse, and go on. How?…

Generating content for the crawler

The idea is to do for the crawler the job that it doesn’t want to do on it’s own, here is where PhantomJS comes in. PhantomJS is a full stack headless browser based on WebKit. Having a fast JavaScript enabled “browser” on the backend allows us to remap the Google bot request back to the #! format, and pass it to PhantomJS. The command-line process will return a nice HTML snapshot to the crawler, just as the users would see on their real browsers, and it will in turn contain more valid #! links to parse, convert and follow so the process goes on.

Depending on your JavaScript, generating a snapshot on the server-side is probably processor-intensive, but remember that it will only be used by the search engine crawlers, and that you will have absolute control over making a snapshot or just returning the cached HTML from a previous run, which will be actually really fast.

Note that any content meant to be indexed needs to be accessible through an <a> element with a proper #! formated href, otherwise it can not be followed by the crawler.

Twitter is an awesome tool to keep in touch with the Agile community (and any other IT related one), I just made a list with all the twitter handles of the people that will be speaking at the conference. There may be some mistakes and inaccuracies as the program has still some TBD entries, some may be wrong or missing altogether. If you spot a mistake please leave a comment!

The part of the workshop I valued most was a completely hands-on game, and it was incredibly fun!, and it was an effective way to transmit how we can apply the TOC to understand and adjust our continuous improvement process in Agile teams.

TOC is based on the premise that the throughput of a goal-oriented system is limited by at least one constraint. Only by increasing flow through the constraint we can increase the overall throughput.

Assuming the goal of a system and its measurements have been defined, the five steps are:

1. Identify the system’s constraint that prevents the organization from obtaining  a higher throughput.
2. Exploit the identified constraint to get the most out of it.
3. Subordinate everything else to the above decision to support it.
4. Elevate the system’s constraint making other major changes needed to break it.
5. Repeat all the previous steps, do not allow inertia to cause a system’s constraint.

The game consisted in 4 iterations of 260 seconds (representing a year of working days) in which each team of five people formed a production chain of paper airplanes. At the end of each iteration, we made changes to the production process based on the first four focusing steps, then we analyzed the production throughput. (in this case, how much money we have made selling good airplanes, or lost making bad or incomplete airplanes).

I am looking forward to try this out in our company soon!

Leaking Pipe – By Gayru (gayru.deviantart.com) C.C. Attribution-Noncommercial-No Derivative Works 3.0

“We expect to be back in <%= deadline %>. For more information, check out Twitter Status. Thanks foryour patience!

Following today’s Azure outage and Google Talk being out of service, now Twitter is completely down. What is wrong with the intertubes today?!

According to Microsoft, they [...] are experiencing an availability issue in the West Europe sub-region, which impacts access to hosted services in this region. [...]

No technical explanation is provided on the site whatsoever.

More info at the Azure dashboard

UPDATE:
Microsoft Reports that at 1:33 PM UTC “The issue has been addressed”.

This is the second major outage in 2012 for the Windows Azure cloud as it was hit by downtime on Feb. 29th because of the “Leap Day” incident, triggered by a security certificate date with 29th Feb. on a date.