<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Posts on Jef Claes</title>
    <link>https://jefclaes.be/post/</link>
    <description>Recent content in Posts on Jef Claes</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Sun, 12 Aug 2018 14:58:00 +0200</lastBuildDate>
    
	<atom:link href="https://jefclaes.be/post/feeds/posts/default" rel="self" type="application/rss" />
    
    
    <item>
      <title>GES scavenging and the hidden cost of link events</title>
      <link>https://jefclaes.be/2018/08/ges-scavenging-and-hidden-cost-of-link.html</link>
      <pubDate>Sun, 12 Aug 2018 14:58:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2018/08/ges-scavenging-and-hidden-cost-of-link.html</guid>
      <description>Somewhere around a year ago, we started using GES in production as the primary data store of our new loyalty system. The system stores two types of data.
 External services push batches of dumb downed events to the loyalty system. For example: a user logged on, played a game or participated in a competition. These events are transient by nature. Once the loyalty system has processed them, they only need to be kept around for a few days.</description>
    </item>
    
    <item>
      <title>Amazon Redshift - Fundamentals</title>
      <link>https://jefclaes.be/2018/05/amazon-redshift-fundamentals.html</link>
      <pubDate>Tue, 01 May 2018 14:17:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2018/05/amazon-redshift-fundamentals.html</guid>
      <description>Late 2017, we set out to replace and upgrade our existing reporting and analytics infrastructure with something that would be a better fit for our workloads. Keeping costs and required maintenance at a minimum would be a nice plus, making for an easy sell. After a bit of research, it was obvious Amazon Redshift had the potential to tick all the right boxes. While steadily porting the most problematic workloads away from our existing infrastructure, I started writing an investigative article on the fundamental concepts of Amazon Redshift.</description>
    </item>
    
    <item>
      <title>Consumed in 2017</title>
      <link>https://jefclaes.be/2018/01/consumed-in-2017.html</link>
      <pubDate>Wed, 03 Jan 2018 21:28:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2018/01/consumed-in-2017.html</guid>
      <description>Another year, another 17 books, 6 shows and 3 movies consumed. Here&amp;rsquo;s this year&amp;rsquo;s highlights.
Books The Zen and Art of Motor Cycle Maintenance The author is a tormented soul on a quest to define quality. You&amp;rsquo;re his passenger, driving shot gun on a CB77 Super Hawk, in for an exhausting intellectual journey through the high mountains of reasoning. You will often fear getting lost and feel slightly anxious that the driver might drive of a cliff any moment, but he won&amp;rsquo;t.</description>
    </item>
    
    <item>
      <title>Passing the AWS Certified Solutions Architect exam</title>
      <link>https://jefclaes.be/2017/12/passing-aws-certified-solutions.html</link>
      <pubDate>Fri, 15 Dec 2017 20:34:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2017/12/passing-aws-certified-solutions.html</guid>
      <description>Before last week, the only certification exam I ever passed was the Microsoft .NET Framework Application Development Foundation certification. This was almost eight years ago. My manager back then thought getting certified was the best way for me to get a raise. It would be a win-win. I for one would learn something along the way, and the company would have less trouble keeping its Microsoft Gold partnership. As far as I remember, I spent a good six months reading, studying and memorizing this 794 pages thick book.</description>
    </item>
    
    <item>
      <title>Fast projections</title>
      <link>https://jefclaes.be/2017/07/fast-projections.html</link>
      <pubDate>Sun, 30 Jul 2017 14:34:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2017/07/fast-projections.html</guid>
      <description>Most EventStore client libraries allow you to subscribe to a stream by passing in a callback which is invoked when an event occurs (either a live or historic event).
type Envelope = { Id : Int64 Event : Event Historic : bool } type EventOccurred = Envelope -&amp;gt; unit Let&amp;rsquo;s say we subscribe to a stream of a popular video service, and we want to project a read model that shows how many videos a viewer has watched.</description>
    </item>
    
    <item>
      <title>From human decisions, to suggestions to automated decisions</title>
      <link>https://jefclaes.be/2017/07/from-human-decisions-to-suggestions-to.html</link>
      <pubDate>Sun, 23 Jul 2017 08:48:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2017/07/from-human-decisions-to-suggestions-to.html</guid>
      <description>I&amp;rsquo;ve been wanting to share this experience for a while, but it took me a while to come up with a story and example I could use in a blog post.
I help out during the weekends in a small family run magic shop. I&amp;rsquo;m the third generation working in the shop. My great-grandfather always hoped that his only son would follow in his footsteps as a carpenter. But at only eighteen years old, my grandfather said goodbye to the chisels and sawdust, and set out for the big city to chase his dream of becoming a world class magician.</description>
    </item>
    
    <item>
      <title>How to organize a meetup</title>
      <link>https://jefclaes.be/2017/02/how-to-organize-meetup.html</link>
      <pubDate>Mon, 13 Feb 2017 21:21:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2017/02/how-to-organize-meetup.html</guid>
      <description>I&amp;rsquo;ve organized a few DDDBE meetups in the past, and always succeed in forgetting something. Either someone points it out well in advance, or I end up stressing last minute. This post partly serves as a checklist for myself, but it would be a welcome side effect to also see it encourage others to help out organizing future meetups. Organizing a meetup is not rocket science, having a list of what to take care of is a good start.</description>
    </item>
    
    <item>
      <title>Printing money - hacking loyalty points</title>
      <link>https://jefclaes.be/2017/02/printing-money-hacking-loyalty-points/</link>
      <pubDate>Sun, 12 Feb 2017 00:20:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2017/02/printing-money-hacking-loyalty-points/</guid>
      <description>At work, we&amp;rsquo;ve all grown quite vigilant when it comes to customers trying to cheat the system. A necessary trait when working in a domain where money flows back and forth and customers are always trying to find an edge that will turn the tables.
While most tend to leave this mindset at work, one colleague in particular, is always probing, trying to find cracks in the surface of everyday models.</description>
    </item>
    
    <item>
      <title>Everyone has to serve somebody, but software has to serve more than one</title>
      <link>https://jefclaes.be/2017/01/gotta-serve-somebody-or-somebodies.html</link>
      <pubDate>Fri, 13 Jan 2017 15:08:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2017/01/gotta-serve-somebody-or-somebodies.html</guid>
      <description>When people get paid to write software, we very often find some form of friction between the people that build the software and those that pay to have it built.
The company I joined three years ago was no exception. When I joined, they had just launched three months ago, weren&amp;rsquo;t seeing any return on investment and prospects weren&amp;rsquo;t too bright either.
I won&amp;rsquo;t lie, that first year was quite stressful.</description>
    </item>
    
    <item>
      <title>Consumed in 2016</title>
      <link>https://jefclaes.be/2016/12/consumed-in-2016.html</link>
      <pubDate>Tue, 27 Dec 2016 22:10:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2016/12/consumed-in-2016.html</guid>
      <description>I&amp;rsquo;m keeping the tradition alive, sharing how much I&amp;rsquo;ve consumed over the last year highlighting the things that stood out. 18 books, 8 movies and 9 shows. Looks like I consumed more than other years, which probably also explains why I produced less after-hours.
Books I finished the Dark Tower series after 3 years. Following Roland Deschain and his ka-tet throughout the 8 books has been an epic adventure. Finishing Harry Potter by the time I was 18, I had little hopes to be ever dragged into such a long and captivating tale ever again.</description>
    </item>
    
    <item>
      <title>Commands and events with JustSaying and AWS</title>
      <link>https://jefclaes.be/2016/09/commands-and-events-with-justsaying-and.html</link>
      <pubDate>Sun, 18 Sep 2016 20:52:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2016/09/commands-and-events-with-justsaying-and.html</guid>
      <description>I&amp;rsquo;ve been looking into handing a bit of our messaging infrastructure over to a managed alternative. Managing your own messaging infrastructure that should be highly available is not always an investment you want to make in this day and age. Going through the documentation and relying on experiences from some people I trust, I ended up looking at AWS and SNS/SQS.
Making the Github repository rounds, looking for inspiration, I stumbled on JustSaying: a library by the people from JustEat implementing a message bus on top of AWS.</description>
    </item>
    
    <item>
      <title>My InfoQ interview on DDD, events and legacy</title>
      <link>https://jefclaes.be/2016/08/my-infoq-article-on-ddd-events-and.html</link>
      <pubDate>Sun, 21 Aug 2016 15:07:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2016/08/my-infoq-article-on-ddd-events-and.html</guid>
      <description>Seems that it&amp;rsquo;s impossible to beat the Gaussian curve of blogging frequency. On the other hand, I spent quite some of my mental blogging budget on an interview with InfoQ.
I&amp;rsquo;m a bit bummed out that it&amp;rsquo;s such a large wall of text. When submitting the answers, I highlighted some snippets which should make for easier scanning. Too bad the formatting was lost when publishing it. I included some highlights below.</description>
    </item>
    
    <item>
      <title>Pieter Hintjens</title>
      <link>https://jefclaes.be/2016/04/pieter-hintjens.html</link>
      <pubDate>Wed, 27 Apr 2016 22:47:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2016/04/pieter-hintjens.html</guid>
      <description>Writing doesn&amp;rsquo;t necessarily always come naturally to me. It often takes me days, weeks or even months of toying with an idea, before I think it&amp;rsquo;s mature enough to put it down into writing. I can&amp;rsquo;t afford that luxury this time though, I wouldn&amp;rsquo;t think of myself as much of a friend if Pieter didn&amp;rsquo;t get to read this in time.
I met Pieter the first time in a bar in Vilnius, December 2013, I accidentally ended up sitting next to him during the traditional pre-conf drinks.</description>
    </item>
    
    <item>
      <title>Using a batch layer for fast(er) aggregations </title>
      <link>https://jefclaes.be/2016/04/using-batch-layer-for-faster.html</link>
      <pubDate>Sun, 24 Apr 2016 22:43:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2016/04/using-batch-layer-for-faster.html</guid>
      <description>In the oldest system I&amp;rsquo;m maintaining right now, we have an account aggregate that, next to mutating various balances, produces immutable financial transactions. These transactions are persisted together with the aggregate itself to a relational database. The transactions can be queried by the owner of the account in an immediate consistent fashion.
The table with these transactions looks similar to this:
CREATE TABLE [dbo].[Transaction] ( [Id] [int] IDENTITY(1,1) NOT NULL, [Timestamp] [datetime] NULL, [AccountId] [int] NOT NULL, [TransactionType] [varchar](25) NOT NULL, [CashAmount] [decimal](19, 2) NOT NULL, [BonusAmount] [decimal](19, 2) NOT NULL, [.</description>
    </item>
    
    <item>
      <title>Notifications from an event log</title>
      <link>https://jefclaes.be/2016/04/notifications-from-event-log.html</link>
      <pubDate>Sun, 17 Apr 2016 17:37:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2016/04/notifications-from-event-log.html</guid>
      <description>User notifications are a feature that came as an afterthought, but turned out to be rather easy to implement - without touching (read: breaking) existing functionality - thanks to having an immutable event log.
In the domain I&amp;rsquo;m working in at the moment, we will often give users incentives to return to the website, or to extend their stay on the website. These incentives were only communicated by email at first, and this is a decent medium when you want users to return to the website.</description>
    </item>
    
    <item>
      <title>Functional one-liner for running totals in C#</title>
      <link>https://jefclaes.be/2016/03/functional-one-liner-for-running-totals.html</link>
      <pubDate>Mon, 28 Mar 2016 16:22:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2016/03/functional-one-liner-for-running-totals.html</guid>
      <description>Visualizing some data earlier this week I had to compute the running total of a sequence of numbers.
For example, if the input sequence was [ 100; 50; 25 ] the result of the computation would be a new sequence of [ 100; 150; 175 ].
Muscle memory made me take a procedural approach, which works, but made me wonder if I could get away with less lines of code and without mutable state.</description>
    </item>
    
    <item>
      <title>Consumed in 2015</title>
      <link>https://jefclaes.be/2016/01/consumed-in-2015.html</link>
      <pubDate>Fri, 01 Jan 2016 14:49:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2016/01/consumed-in-2015.html</guid>
      <description>I started in 2014 to keep lists of everything I consume. I&amp;rsquo;ve continued this effort throughout 2015 and can now share the items I particularly enjoyed.
In 2015, I read 16 books and 3 papers, watched 3 movies and 4 shows, listened to 1 audio book and no podcasts. A lot less TV compared to 2014, but most of that time went to playing video games with some of my friends.</description>
    </item>
    
    <item>
      <title>Visualizing event streams</title>
      <link>https://jefclaes.be/2015/12/visualizing-event-streams.html</link>
      <pubDate>Sun, 20 Dec 2015 17:59:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2015/12/visualizing-event-streams.html</guid>
      <description>In my recent talk on Evil by Design, I showed how I&amp;rsquo;ve been visualizing event streams as a means to get a better grip on how aggregates behave in production. The talk&amp;rsquo;s scope kept me from showing the code that goes together with the examples shown. Consider this post as an addendum to that talk.
First off, we need a few types: a string that identifies a stream, an event containing a timestamp and its name.</description>
    </item>
    
    <item>
      <title>Slides from my talk &#34;Evil by Design&#34; at Build Stuff</title>
      <link>https://jefclaes.be/2015/11/slides-from-my-talk-evil-by-design-at.html</link>
      <pubDate>Wed, 18 Nov 2015 15:47:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2015/11/slides-from-my-talk-evil-by-design-at.html</guid>
      <description>Third time attending Build Stuff, first time doing a talk. I&amp;rsquo;m happy that it&amp;rsquo;s out of the way and can now just enjoy the conference, but I&amp;rsquo;m even more excited that it was well-received! The talk should have been recorded, but you can already find the abstract and slides below.
 Last year I ventured into the domain of (online) gambling. Given that the industry has been around since forever, I expected most problems to be of the technical kind.</description>
    </item>
    
    <item>
      <title>Defining big wins</title>
      <link>https://jefclaes.be/2015/11/defining-big-wins.html</link>
      <pubDate>Mon, 16 Nov 2015 21:31:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2015/11/defining-big-wins.html</guid>
      <description>Casinos invest a lot of energy selling the dream. One way to do this is by showing off people winning big in your casino. Everyone has seen those corny pictures of people holding human-sized cheques right? It&amp;rsquo;s a solid tactic, since empirical evidence shows that after a store has sold a large-prize winning lottery ticket, the ticket sales increase from 12 to 38% over the following weeks.
If we look at slot machine play, what exactly defines a big win?</description>
    </item>
    
    <item>
      <title>Bulk SQL projections with F# and type providers</title>
      <link>https://jefclaes.be/2015/10/bulk-sql-projections-with-f-and-type.html</link>
      <pubDate>Sun, 18 Oct 2015 15:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2015/10/bulk-sql-projections-with-f-and-type.html</guid>
      <description>Early Summer, I had to set up an integration with an external partner. They required of us to daily provide them with a relational dataset stored in SQL Server. Most, if not all of the data was temporal, append-only by nature; think logins, financial transactions..
Since the data required largely lived in an eventstore on our end, I needed fast bulk projections. Having experimented with a few approaches, I eventually settled on projections in F# taking advantage of type providers.</description>
    </item>
    
    <item>
      <title>Aspect ratio calculation</title>
      <link>https://jefclaes.be/2015/09/aspect-ratio-calculation.html</link>
      <pubDate>Fri, 11 Sep 2015 23:40:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2015/09/aspect-ratio-calculation.html</guid>
      <description>Earlier today I was writing a migration script in F# where I had to calculate the aspect ratio based on the given screen dimensions. This is one of those problems where I don&amp;rsquo;t even mind breaking my head over, but directly head over to Stackoverflow to find an accepted answer which I can just copy paste. Since I didn&amp;rsquo;t find an F# snippet I could use, I ported some JavaScript, and embedded the result below for future snippet hunters.</description>
    </item>
    
    <item>
      <title>Basic casino math</title>
      <link>https://jefclaes.be/2015/06/basic-casino-math.html</link>
      <pubDate>Mon, 22 Jun 2015 22:52:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2015/06/basic-casino-math.html</guid>
      <description>In a previous series of posts, I went over the models used by casinos to spin a wheel (spinning, manipulating the odds, clustering and near misses). I did not yet expand on the basic mathematical models that ensure a casino makes money.
Let&amp;rsquo;s pretend we are spinning the wheel again. The wheel has 5 pockets, and just one of those is the winning one. Given we will be using an unmodified wheel, you win 1 out of 5 spins.</description>
    </item>
    
    <item>
      <title>Consumed: Queries and projections (F#)</title>
      <link>https://jefclaes.be/2015/05/consumed-queries-and-projections-f.html</link>
      <pubDate>Sun, 24 May 2015 18:00:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2015/05/consumed-queries-and-projections-f.html</guid>
      <description>This is the third post in my series on porting a node.js application to an F# application.
So far, I&amp;rsquo;ve looked at parsing command line arguments, handling commands and storing events. Today, I want to project those events into something useful that can be formatted and printed to the console.
In the original application, I only had a single query. The result of this query lists all items consumed grouped by category, sorted chronologically.</description>
    </item>
    
    <item>
      <title>Consumed: Handling commands (F#)</title>
      <link>https://jefclaes.be/2015/05/consumed-handling-commands-f.html</link>
      <pubDate>Sun, 17 May 2015 17:51:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2015/05/consumed-handling-commands-f.html</guid>
      <description>As I wrote earlier, I&amp;rsquo;ve been working on porting a node.js web application to an F# console application. It&amp;rsquo;s an application I wrote to learn node.js but still use today to keep track of all the things I consume.
The application is able to consume an item, to remove a consumed item and to query all consumed items.
In the previous post, I parsed command line arguments into typed commands and queries.</description>
    </item>
    
    <item>
      <title>Finding unused code (F#)</title>
      <link>https://jefclaes.be/2015/04/finding-unused-code-f.html</link>
      <pubDate>Sun, 26 Apr 2015 18:06:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2015/04/finding-unused-code-f.html</guid>
      <description>Coming from C#, I&amp;rsquo;m used to the compiler warning me about unused variables. Relying on the compiler to help me with checked exceptions in F#, I noticed that unused values (and functions) would go unnoticed. Having accidentally read earlier that Haskell has a compiler flag to check for unused bindings, I looked for the F# equivalent but failed to find it, until Scott Wlaschin pointed me in the right direction.</description>
    </item>
    
    <item>
      <title>Consumed: Parsing command line arguments (F#)</title>
      <link>https://jefclaes.be/2015/04/parsing-command-line-arguments-with-f.html</link>
      <pubDate>Sun, 19 Apr 2015 16:54:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2015/04/parsing-command-line-arguments-with-f.html</guid>
      <description>Last year, I set out to write my first node.js application; a small web application for keeping lists of everything I consume. I had something working pretty quickly, deployed it to Heroku and still find myself using it today. Since there&amp;rsquo;s very little use for having it running on a server, and because I wanted something to toy with getting better at F#, I decided to port it to an F# console application.</description>
    </item>
    
    <item>
      <title>Checked errors in F#</title>
      <link>https://jefclaes.be/2015/03/checked-errors-in-f.html</link>
      <pubDate>Sun, 29 Mar 2015 17:19:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2015/03/checked-errors-in-f.html</guid>
      <description>In the land of C#, exceptions are king. By definition exceptions help us deal with &amp;ldquo;unexpected or exceptional situations that arise while a program is running&amp;rdquo;. In that regard, we&amp;rsquo;re often optimistic, overoptimistic. Most code bases treat errors as exceptional while they&amp;rsquo;re often commonplace. We are so confident about the likelyhood of things going wrong, we don&amp;rsquo;t even feel the need to communicate to consumers what might go wrong. If a consumer of a method wants to know what exceptions might be thrown, he needs to resort to reading the documentation (or source) and hope it&amp;rsquo;s up-to-date.</description>
    </item>
    
    <item>
      <title>Scaling promotion codes</title>
      <link>https://jefclaes.be/2015/03/scaling-promotion-codes/</link>
      <pubDate>Sun, 15 Mar 2015 18:01:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2015/03/scaling-promotion-codes/</guid>
      <description>In our system a backoffice user can issue a promotion code for users to redeem. Redeeming a promotion code, a user receives a discount on his next purchase or a free gift. A promotion code is only active for a limited amount of time, can only be redeemed a limited amount of times and can only be redeemed once per user.
public bool TryRedeem(UserId userId) { if (HasAlreadyBeenRedeemedByUser(userId)) return false; if (NoLongerActive()) return false; if (Depleted()) return false; Apply(new PromotionCodeRedeemed(userId.</description>
    </item>
    
    <item>
      <title>Domain Language: The Playthrough Bonus</title>
      <link>https://jefclaes.be/2015/02/domain-language-playthrough-bonus.html</link>
      <pubDate>Mon, 23 Feb 2015 19:05:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2015/02/domain-language-playthrough-bonus.html</guid>
      <description>Since online gambling has been regulated in Belgium, basically each eligible license holder has complemented their land based operations with an online counterpart. Being such a small country, everyone wants to secure their market share as soon as possible. The big players have been pouring tons of money in to marketing and advertising, it&amp;rsquo;s everywhere: radio, television, (online) newspapers, bus stops, billboards, sport events, airplane vouchers - you name it. While regulations for land based casinos are very strict and almost overprotective, regulations for online play are much more permissive.</description>
    </item>
    
    <item>
      <title>Side by side</title>
      <link>https://jefclaes.be/2015/02/side-by-side.html</link>
      <pubDate>Sun, 15 Feb 2015 17:34:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2015/02/side-by-side.html</guid>
      <description>This week marked my first year at my current employer. While that event went by rather silently, one year in, a few of my observations are finally shaping up to be cast into writing.
Where I used to work in the typical battery cage, I&amp;rsquo;m now part of a team of just four people, having the luxury of a big dedicated room to ourselves - a whole floor actually. The room is set up almost symmetrically; two desks on one side of the room and two more on the other side, with quite some space in between.</description>
    </item>
    
    <item>
      <title>Averages are not good enough (F#)</title>
      <link>https://jefclaes.be/2015/01/averages-are-not-good-enough-f.html</link>
      <pubDate>Sun, 18 Jan 2015 18:40:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2015/01/averages-are-not-good-enough-f.html</guid>
      <description>Let&amp;rsquo;s (no pun intended) look at a set of response times of a web service.
let responseTimes = [ 18.0; 21.0; 41.0; 42.0; 48.0; 50.0; 55.0; 90.0; ] People like having a single number to summarize a piece of data. The average is the most popular candidate. The average is calculated by dividing the sum of the input elements by the number of input elements.
let average input = let length = input |&amp;gt; Seq.</description>
    </item>
    
    <item>
      <title>Consumed in 2014</title>
      <link>https://jefclaes.be/2015/01/consumed-in-2014.html</link>
      <pubDate>Sun, 11 Jan 2015 17:45:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2015/01/consumed-in-2014.html</guid>
      <description>Starting 2014, I wanted to look more closely at everything I consume. So I started keeping a list of everything I read, watch and listen to.
I started off with a markdown file on Github that quikcly evolved into a good excuse to dabble with an alternative stack. I ended up writing an event sourced node.js application on top of postgres, hosted on Heroku. I could write a post on that particular experience, but it&amp;rsquo;s safe to say this blog post captures it better than I ever could.</description>
    </item>
    
    <item>
      <title>TDD as the crack cocaine of software</title>
      <link>https://jefclaes.be/2014/12/tdd-as-crack-cocaine-of-software.html</link>
      <pubDate>Sun, 28 Dec 2014 17:29:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/12/tdd-as-crack-cocaine-of-software.html</guid>
      <description>The psychologist Mihaly Csikszentmihalyi popularized the term &amp;ldquo;flow&amp;rdquo; to describe states of absorption in which attention is so narrowly focused on an activity that a sense of time fades, along with the troubles and concerns of day-to-day life. &amp;ldquo;Flow provides an escape from the chaos of the quotidian,&amp;rdquo; he wrote.  This is a snippet from the highly recommended book Addiction by Design, which not only gives you an incredibly complete overview of the gambling industry, but also insights into the human psyche which apply far outside the domain of gambling.</description>
    </item>
    
    <item>
      <title>Spinning the wheel: clustering and near misses</title>
      <link>https://jefclaes.be/2014/12/spinning-wheel-clustering-and-near.html</link>
      <pubDate>Sun, 14 Dec 2014 17:13:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/12/spinning-wheel-clustering-and-near.html</guid>
      <description>The previous post showed a simple model casinos use to manipulate the odds. Instead of relying on the physical wheel for randomness, they rely on a virtual list of indexes that maps to the physical wheel.
Using that same model, it&amp;rsquo;s easy to fiddle with the virtual indexes so that they map to misses right next to the winning pocket, creating &amp;ldquo;near misses&amp;rdquo;. &amp;ldquo;Near misses&amp;rdquo; make players feel less like losing, since you &amp;ldquo;almost won&amp;rdquo;.</description>
    </item>
    
    <item>
      <title>Spinning the wheel: manipulating the odds</title>
      <link>https://jefclaes.be/2014/12/spinning-wheel-manipulating-odds.html</link>
      <pubDate>Thu, 11 Dec 2014 19:24:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/12/spinning-wheel-manipulating-odds.html</guid>
      <description>The previous post defined a basic set of data structures and functions to spin a wheel of fortune in F#.
There was very little mystery to that implementation though. The physical wheel had four pockets and spinning the wheel would land you a win one out of four spins. As a casino, it&amp;rsquo;s impossible to come up with an interesting payout using this model.
To juice up the pot, casinos started adding more pockets to the wheel of fortune.</description>
    </item>
    
    <item>
      <title>Spinning the wheel</title>
      <link>https://jefclaes.be/2014/12/spinning-wheel.html</link>
      <pubDate>Tue, 09 Dec 2014 19:56:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/12/spinning-wheel.html</guid>
      <description>In this post, I&amp;rsquo;ll define a basic set of data structures and functions to spin a wheel of fortune. In the next post, I&amp;rsquo;ll show you the simple model casinos use to build a bigger, more attractive pot, without touching the physical wheel and without losing money. Finally, I&amp;rsquo;ll show you how casinos tweak that model to bend the odds and create near misses.

Let&amp;rsquo;s say we have a physical wheel with four pockets, which are labeled either miss or win.</description>
    </item>
    
    <item>
      <title>Hot aggregate detection using F#</title>
      <link>https://jefclaes.be/2014/11/hot-aggregate-detection-using-f.html</link>
      <pubDate>Sun, 16 Nov 2014 17:20:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/11/hot-aggregate-detection-using-f.html</guid>
      <description>Last week, I wrote about splitting a hot aggregate. Discovering that specific hot aggregate was easy; it would cause transactional failures from time to time.
Long-lived hot aggregates often are an indication of a missing concept and an opportunity for teasing things apart. Last week, I took one long-lived hot aggregate and pulled smaller short-lived hot aggregates out, identifying two missing concepts.
Hunting for more hot aggregates, I could visualize event streams and use my eyes to detect bursts of activity, or I could have a little function analyze the event streams for me.</description>
    </item>
    
    <item>
      <title>Splitting hot aggregates</title>
      <link>https://jefclaes.be/2014/11/splitting-hot-aggregates.html</link>
      <pubDate>Sun, 09 Nov 2014 19:00:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/11/splitting-hot-aggregates.html</guid>
      <description>When you visit a real casino, the constant busy-ness is overwhelming; players spamming buttons, pulling levers, spinning the wheel, gambling on the outcome of sports games, playing cards, feeding the machine, cashing out, breaking bills, ordering drinks or even buying a souvenir. A single player will easily generate a thousand transactions in one sitting.
When you look at an online casino, this isn&amp;rsquo;t very different. In the system we inherited, the biggest and busiest aggregate by far is a user&amp;rsquo;s account.</description>
    </item>
    
    <item>
      <title>Programmatically force create a new LocalDB database</title>
      <link>https://jefclaes.be/2014/10/programmatically-force-create-new.html</link>
      <pubDate>Sun, 26 Oct 2014 16:59:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/10/programmatically-force-create-new.html</guid>
      <description>I have spent the last week working in an integration test suite that seemed to be taking ages to run its first test. I ran a profiler on the setup, and noticed a few things that were cheap to improve. The first one was how a new LocalDB database was being created.
An empty database file was included into the project. When running the setup, this file would replace the existing test database.</description>
    </item>
    
    <item>
      <title>Print out the maximum depth of recursion allowed</title>
      <link>https://jefclaes.be/2014/10/print-out-maximum-depth-of-recursion.html</link>
      <pubDate>Sun, 19 Oct 2014 17:33:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/10/print-out-maximum-depth-of-recursion.html</guid>
      <description>Karl Seguin tweeted the following earlier this week: &amp;ldquo;An interview question I sometimes ask: Write code that prints out the maximum depth of recursion allowed.&amp;rdquo;
This question is interesting for a couple of reasons. First, it&amp;rsquo;s a shorter FizzBuzz; can the candidate open an IDE, write a few lines of code, compile and run them? And second, does he know what recursion is?
Now let&amp;rsquo;s say, the interviewee knows how to write code and is familiar with the concept of recursion.</description>
    </item>
    
    <item>
      <title>Read an Event Store stream as a sequence of slices using F#</title>
      <link>https://jefclaes.be/2014/10/read-event-store-stream-as-sequence-of.html</link>
      <pubDate>Sun, 05 Oct 2014 15:21:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/10/read-event-store-stream-as-sequence-of.html</guid>
      <description>I&amp;rsquo;m slowly working on some ideas I&amp;rsquo;ve been playing around with whole Summer. Since that&amp;rsquo;s taking me to unknown territory, I guess I&amp;rsquo;ll be putting out more technical bits here in the next few weeks.
Using the Event Store, I tried to read all events of a specific event type. This stream turned out to be a tad too large to be sent over the wire in one piece, leading to a PackageFramingException: Package size is out of bounds.</description>
    </item>
    
    <item>
      <title>The road to Großglockner</title>
      <link>https://jefclaes.be/2014/09/the-road-to-groglockner.html</link>
      <pubDate>Sun, 14 Sep 2014 21:01:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/09/the-road-to-groglockner.html</guid>
      <description>Sixteen days after leaving home, we&amp;rsquo;re now on our way back to Antwerp. After Croatia, we&amp;rsquo;ve driven through Slovenia, Italy, Austra and Switzerland, arriving in France to meet up with my parents for a few days.
France offered us the typical vineyards and chateaux. What, next to the good company, will stick with me the most is the High Alpine road in Austria. We paid 34 euros to be allowed on the road, but the surroundings of that piece of asphalt are extraordinary.</description>
    </item>
    
    <item>
      <title>Northbound again</title>
      <link>https://jefclaes.be/2014/09/northbound-again.html</link>
      <pubDate>Wed, 10 Sep 2014 11:25:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/09/northbound-again.html</guid>
      <description>Leaving Plitvice behind us, we crossed the country heading for the sea. We didn&amp;rsquo;t need to cover a lot of distance, to discover how diverse the Croatian landscape and climate is. In only two hours we went from the cold, foggy lakes and waterfalls to green meadows to dusty mountains to sunbathing coasts.


We followed the coastline for a little while, strolling through old coast towns, eating seafood, drinking something cold.</description>
    </item>
    
    <item>
      <title>Tolkien&#39;s inspiration</title>
      <link>https://jefclaes.be/2014/09/tolkiens-inspiration.html</link>
      <pubDate>Sun, 07 Sep 2014 10:36:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/09/tolkiens-inspiration.html</guid>
      <description>The next morning we woke up to another rainy day. We caught up with the rain in Austria and we have been following it ever since. Or the other way around. Even the locals can&amp;rsquo;t seem to stop talking about how much rain is falling.
Between showers, we were able to hike the Vintgar trail. The one hour hike takes you along dangerous rapid waters, bringing you to a big waterfall.</description>
    </item>
    
    <item>
      <title>Porsches and a setting that sells them</title>
      <link>https://jefclaes.be/2014/09/porsches-and-setting-that-sells-them.html</link>
      <pubDate>Tue, 02 Sep 2014 22:24:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/09/porsches-and-setting-that-sells-them.html</guid>
      <description>With the Belgian &amp;lsquo;Summer&amp;rsquo; ending, we are exploring South Eastern Europe. This trip will take us through Germany, Austria, Slovenia and Croatia.
On Saturday, we stopped in Stuttgart to complete our list of visits to the three most popular European sports car museums, after visiting Lamborghini and Ferrari two years ago: the Porsche museum. In my teens, my affinity to fast cars was ignited by spending rainy afternoons at one of my best friends&amp;rsquo;s, attempting to crush each other&amp;rsquo;s track records playing Need For Speed Porsche Unleashed.</description>
    </item>
    
    <item>
      <title>Solomon, the architect</title>
      <link>https://jefclaes.be/2014/08/solomon-architect.html</link>
      <pubDate>Tue, 26 Aug 2014 19:52:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/08/solomon-architect.html</guid>
      <description>Two junior developers who started working for the company at the same time, had been quite competitive with each other from the get-go. They had once been assigned to the same team, but because of the constant bickering, which had put a serious amount of stress on the team, one of them was pulled off the project and reassigned.
A good year later, just the two of them were assigned to a new smallish, but interesting in-house project.</description>
    </item>
    
    <item>
      <title>Thinking No Computers</title>
      <link>https://jefclaes.be/2014/08/thinking-no-computers/</link>
      <pubDate>Tue, 19 Aug 2014 20:09:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/08/thinking-no-computers/</guid>
      <description>The other day I happened to see a curious exchange in one of our businesses. The cashier swapped a torn, but carefully restored by taping it together again, Euro bill for a new one with the manager. Inquisitive, I asked the manager what he was planning to do with that Euro bill. &amp;ldquo;Once a month, I take all those ripped up or badly worn bills to the National Bank, and trade them for new ones.</description>
    </item>
    
    <item>
      <title>Paper notes: A Study and Toolkit for Asynchronous Programming in C#</title>
      <link>https://jefclaes.be/2014/06/paper-notes-study-and-toolkit-for.html</link>
      <pubDate>Sun, 08 Jun 2014 18:33:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/06/paper-notes-study-and-toolkit-for.html</guid>
      <description>The .NET framework mainly provides two models for asynchronous programming: (1) the Asynchronous Programming Model (APM), that uses callbacks, and (2) the Task Asynchronous Pattern (TAP), that uses Tasks, which are similar to the concept of futures.
The Task represents the operation in progress, and its future result. The Task can be (1) queried for the status of the operation, (2) synchronized upon to wait for the result of the operation, or (3) set up with a continuation that resumes in the background when the task completes.</description>
    </item>
    
    <item>
      <title>Not about the UI and the database</title>
      <link>https://jefclaes.be/2014/06/not-about-ui-and-database.html</link>
      <pubDate>Sun, 01 Jun 2014 17:55:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/06/not-about-ui-and-database.html</guid>
      <description>When you ask an outsider which components an average application consists of, he will most likely be able to identify the user interface and the database. He will also recognize that there is something in between that takes the input from the user interface, applies some logic and persists the result in the database.

In the past, trying to make sense of what goes on the middle, we started</description>
    </item>
    
    <item>
      <title>Eventual consistency in the Wild West</title>
      <link>https://jefclaes.be/2014/05/eventual-consistency-in-wild-west.html</link>
      <pubDate>Sun, 25 May 2014 18:01:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/05/eventual-consistency-in-wild-west.html</guid>
      <description>San Francisco, 1852. With the California Gold Rush at its peak, successful gold-seekers wanted to protect all their precious gold nuggets by storing them in a strong safe. At the time, it wasn&amp;rsquo;t that easy to have access to a safe though. At the very beginning, it were just a few local merchants that owned one. Not much later, bankers swamped the area hoping to get their piece of the pie - bringing the strongest safes money can buy.</description>
    </item>
    
    <item>
      <title>NCrafts Eventstorming slides</title>
      <link>https://jefclaes.be/2014/05/ncrafts-eventstorming-slides.html</link>
      <pubDate>Fri, 16 May 2014 15:22:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/05/ncrafts-eventstorming-slides.html</guid>
      <description>Me and Tom just finished doing our Event storming workshop at NCrafts Paris. Although we made a few mistakes along the way, feedback on the workshop was great. I hope to put something out about what we learned facilitating later this week. People talked, discovered and eventually learned a new domain in under two hours. The domain? Two minutes before the workshop we found a domain expert prepared to talk about his coupon start-up.</description>
    </item>
    
    <item>
      <title>What if we stored events instead of state? - slides</title>
      <link>https://jefclaes.be/2014/05/what-if-we-stored-events-instead-of.html</link>
      <pubDate>Mon, 12 May 2014 17:41:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/05/what-if-we-stored-events-instead-of.html</guid>
      <description>I just returned from Croatia, where I got to speak twice at the second edition of The Geek Gathering.
Being such a young conference, I had no idea what to expect. Turns out they have a good thing going on; a small, local and very personal approach to conferences. Speakers both local and international, covering topics that serve the community, not their employer.
Together with Tom, I preached Alberto&amp;lsquo;s Event Storming during a four hour long workshop.</description>
    </item>
    
    <item>
      <title>Glueing the browser and POS devices together </title>
      <link>https://jefclaes.be/2014/05/glueing-browser-and-pos-devices-together.html</link>
      <pubDate>Sun, 04 May 2014 18:23:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/05/glueing-browser-and-pos-devices-together.html</guid>
      <description>I have been occupied building a modest Point of Sale system over these last few weeks. Looking at implementing the client, there were two constraints; it needed to run on Windows and it should be able to talk to devices such as a ticket printer and a card reader.
Although we could use any Windows client framework, we like building things in the browser better for a number of reasons; platform-independence, familiar user experience, JavaScript&amp;rsquo;s asynchronous programming model and its incredible rich ecosystem.</description>
    </item>
    
    <item>
      <title>Solving Mavericks with VMware Fusion 6 and Windows 8.1 hangs</title>
      <link>https://jefclaes.be/2014/04/solving-mavericks-with-vmware-fusion-6.html</link>
      <pubDate>Mon, 21 Apr 2014 12:07:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/04/solving-mavericks-with-vmware-fusion-6.html</guid>
      <description>Since I intended to avoid Windows at home, I got a Macbook Pro starting out at my new job. Overall it has been a great machine for doing development; it&amp;rsquo;s fast, light enough to carry around, its battery life is outstanding, it has a screen that&amp;rsquo;s gentle to the eyes, and full screen apps together with powerful mouse gestures allow me to quickly shuffle between things not missing touch or a second monitor.</description>
    </item>
    
    <item>
      <title>Rebinding a knockout view model</title>
      <link>https://jefclaes.be/2014/04/rebinding-knockout-viewmodel.html</link>
      <pubDate>Sun, 06 Apr 2014 18:43:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2014/04/rebinding-knockout-viewmodel.html</guid>
      <description>As you might have noticed reading my last two posts, I have been doing a bit of front-end work using knockout.js. Here is something that had me scratching my head for a little while..
In one of our pages we&amp;rsquo;re subscribing to a specific event. As soon as that event arrives, we need to reinitialize the model that is bound to our container element. Going through snippets earlier, I remembered seeing the cleanNode function being used a few times - which I thought would remove all knockout data and event handlers from an element.</description>
    </item>
    
    <item>
      <title>Sending commands from a knockout.js view model</title>
      <link>https://jefclaes.be/2014/03/sending-commands-from-knockoutjs-view.html</link>
      <pubDate>Sun, 23 Mar 2014 18:31:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/03/sending-commands-from-knockoutjs-view.html</guid>
      <description>While I got to use angular.js for a good while last year, I found myself returning to knockout.js for the current application I&amp;rsquo;m working on. Where angular.js is a heavy, intrusive, opinionated, but also very complete framework, knockout.js is a small and lightweight library giving you not much more than a dynamic model binder. So instead of blindly following the angular-way, I&amp;rsquo;ll have to introduce my own set of abstractions and plumbing again; I assume that I&amp;rsquo;ll end up with a lot less.</description>
    </item>
    
    <item>
      <title>Building a live dashboard with some knockout</title>
      <link>https://jefclaes.be/2014/03/building-live-dashboard-with-some.html</link>
      <pubDate>Sun, 16 Mar 2014 21:23:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/03/building-live-dashboard-with-some.html</guid>
      <description>Last week, we added a dashboard to our back office application that shows some actionable data about what&amp;rsquo;s going on in our system. Although we have infrastructure in place to push changes to the browser, it seemed more reasonable to have the browser fetch fresh data every few minutes.
We split the dashboard up in a few functional cohesive widgets. On the server, we built a view-optimized read model for each widget.</description>
    </item>
    
    <item>
      <title>Tests as part of your code</title>
      <link>https://jefclaes.be/2014/03/tests-as-part-of-your-code.html</link>
      <pubDate>Sun, 09 Mar 2014 18:13:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/03/tests-as-part-of-your-code.html</guid>
      <description>In the last project I worked on - processing financial batches - we put a lot of effort in avoiding being silently wrong. The practice that contributed most was being religious about avoiding structures to ever be in an invalid state. Preconditions, invariants, value objects and immutability were key.
One of the things we had to do with these structures was writing them to disk in a specific banking format; all the accounts with their transactions for a specific day.</description>
    </item>
    
    <item>
      <title>Alternatives to Udi&#39;s domain events</title>
      <link>https://jefclaes.be/2014/03/alternatives-to-udis-domain-events.html</link>
      <pubDate>Sun, 02 Mar 2014 18:21:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/03/alternatives-to-udis-domain-events.html</guid>
      <description>Almost four years ago Udi Dahan introduced an elegant technique that allows you to have your domain model dispatch events without injecting a dispatcher into the model - keeping your model focused on the business at hand.
This works by having a static DomainEvents class which dispatches raised events.
This customer aggregate raises an event when a customer moves to a new address.
public class Customer { private readonly string _id; private Address _address; private Name _name; public Customer(string id, Name name, Address address) { Guard.</description>
    </item>
    
    <item>
      <title>Strategic DDD in a nutshell </title>
      <link>https://jefclaes.be/2014/02/strategic-ddd-in-nutshell.html</link>
      <pubDate>Sun, 23 Feb 2014 18:21:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/02/strategic-ddd-in-nutshell.html</guid>
      <description>There are two big parts to Domain Driven Design; strategy and tactics. Strategy helps setting out a high-level grand design, while tactics enable us to execute on the strategy.
Practicing strategic design, we generally first try to list all of the different parts that make our business a whole; these are sub-domains. When you look at a supermarket chain, you would find sub-domains like real estate management, advertising, suppliers, stock, sales, human resources, finance, security and so on.</description>
    </item>
    
    <item>
      <title>DDDBE slides on the Ubiquitous Language</title>
      <link>https://jefclaes.be/2014/02/dddbe-slides-on-ubiquitous-language.html</link>
      <pubDate>Sun, 16 Feb 2014 18:04:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/02/dddbe-slides-on-ubiquitous-language.html</guid>
      <description>Monday, I and four others did a DDDBE session on the strategic side of Domain Driven Design.
My talk covered the Ubiquitous Language, and can be found on Slideshare. I might end up writing down the content of the talk as well - some images are meaningless without words. Evaluating feedback, I think the biggest mistake we made was keeping some things too abstract - curse of knowledge at work. If we get the chance to repeat the session, we need to make sure to weave a practical story through our talks to make them stick.</description>
    </item>
    
    <item>
      <title>Reading an EventStore stream using JavaScript</title>
      <link>https://jefclaes.be/2014/02/reading-an-eventstore-stream-using-javascript/</link>
      <pubDate>Sun, 09 Feb 2014 18:07:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/02/reading-an-eventstore-stream-using-javascript/</guid>
      <description>Over Christmas break, I set out three days to play with the EventStore. One of the things I wanted to do was visualize the timeline of a stream in the browser. Since the EventStore exposes its event streams over atom in JSON, I could directly consume them from JavaScript.
An event stream can contain quite a few events. Since caching parts of that stream benefits all components in the system, the atom feed is split in multiple pages - where all full pages are cacheable.</description>
    </item>
    
    <item>
      <title>Thinking in Systems</title>
      <link>https://jefclaes.be/2014/02/thinking-in-systems.html</link>
      <pubDate>Sun, 02 Feb 2014 18:19:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/02/thinking-in-systems.html</guid>
      <description>We are surrounded by systems day in, day out. As software developers, we even get to spend a big portion of our day actively building and changing systems - be it software, teams, communities or businesses. Seeing the whole, but more importantly understanding how systems exist of inter-related parts that affect each other in all kinds of interesting ways, is crucial to growing sustainable systems.
Thinking in Systems is a primer on the subject of system thinking written by Donella H.</description>
    </item>
    
    <item>
      <title>Repositories, where did we go wrong?</title>
      <link>https://jefclaes.be/2014/01/repositories-where-did-we-go-wrong_26.html</link>
      <pubDate>Sun, 26 Jan 2014 18:00:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/01/repositories-where-did-we-go-wrong_26.html</guid>
      <description>In essence, repositories are a simple abstraction over aggregate storage. A repository will insert, update, delete or fetch an aggregate from the underlying persistence mechanism. This abstraction avoids that databases, SQL statements, Object Mappers and the like leak into your domain. Next to that, swapping out repositories for an in-memory version makes testing easier.
Recently, the use of repositories is being questioned again.
Why would we wrap Object Mappers in yet another abstraction?</description>
    </item>
    
    <item>
      <title>new YearPassed(2013);</title>
      <link>https://jefclaes.be/2014/01/new-yearpassed2013.html</link>
      <pubDate>Sun, 19 Jan 2014 17:54:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/01/new-yearpassed2013.html</guid>
      <description>I normally write this up at the end of the year, but circumstances made me push back this post for a few weeks. I use this annual post to look back at the year passed, and to look ahead to the year to come. I gave up on making resolutions in 2011. This year, I&amp;rsquo;m going to be naively ambitious again going into 2014.
Compared to previous years, I feel more confident that I have a pretty good idea of what I want next.</description>
    </item>
    
    <item>
      <title>Happiness before success</title>
      <link>https://jefclaes.be/2014/01/happiness-before-success.html</link>
      <pubDate>Sun, 12 Jan 2014 18:57:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/01/happiness-before-success.html</guid>
      <description>Somewhere in the beginning of last century, two shoes salesmen were sent to Africa hoping to expand their employer&amp;rsquo;s market. Both salesmen reported home within days of their arrival. The first salesman wrote: &amp;ldquo;This trip turned out to be a waste of time; the locals are not wearing any shoes.&amp;rdquo; The second salesman wrote something similar, yet very different: &amp;ldquo;This is looking very promising; people aren&amp;rsquo;t wearing any shoes yet!&amp;rdquo;</description>
    </item>
    
    <item>
      <title>Command and event semantics</title>
      <link>https://jefclaes.be/2014/01/command-and-event-semantics.html</link>
      <pubDate>Sun, 05 Jan 2014 18:12:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2014/01/command-and-event-semantics.html</guid>
      <description>Yesterday, I read this blog post by Michael Feathers. In the post he goes over a pain point he has often found himself struggling with while breaking down a large method; conditional statements. if (alarmEnabled) { var alarm = new Alarm(); ... alarm.Sound(); } Should we extract the if and the associated block into a new method, or just the content of the block? Is the condition too important to hide in a method?</description>
    </item>
    
    <item>
      <title>2013&#39;s most read posts</title>
      <link>https://jefclaes.be/2013/12/2013s-most-read-posts.html</link>
      <pubDate>Sun, 29 Dec 2013 17:05:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/12/2013s-most-read-posts.html</guid>
      <description>This time of year, we&amp;rsquo;re all very busy honoring traditions. This post is no exception (2009, 2010, 2011, 2012).Today was probably the first time this year that I took some time to study my blog&amp;rsquo;s Google Analytics metrics. If I keep last year&amp;rsquo;s black swan posts out of the equation, traffic seems to be comparable to last year&amp;rsquo;s. The most meaningful metrics to me are the number of subscriptions and the average time spent reading.</description>
    </item>
    
    <item>
      <title>Databases are growing on me</title>
      <link>https://jefclaes.be/2013/12/databases-are-growing-on-me.html</link>
      <pubDate>Sun, 22 Dec 2013 21:53:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/12/databases-are-growing-on-me.html</guid>
      <description>I learned all about logical design of relational databases back in school; tables, columns, data types, views, normalization, constraints, primary keys, foreign keys&amp;hellip; At the same time, I learned how to use SQL to put data in, and how to get it out again; INSERT INTO, SELECT, FROM, WHERE, JOIN, GROUP...
In the first project I worked on just out of school, we weren&amp;rsquo;t doing anything interesting with databases; we didn&amp;rsquo;t have that many users, or that much data.</description>
    </item>
    
    <item>
      <title>Buildstuff 2013</title>
      <link>https://jefclaes.be/2013/12/buildstuff-2013.html</link>
      <pubDate>Sun, 15 Dec 2013 22:03:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/12/buildstuff-2013.html</guid>
      <description>Last night, I returned from Vilnius, after seven intensive days of Buildstuff. After a few long months, I was looking forward to be influenced and inspired by concepts and experiences strange to my day-to-day job - surrounded by people hungry to build better software. Because of the diversity of the program, the high level of the speakers and the presence of some familiar DDD-community faces, my expectations were easily met. Also, the location and low rates for tickets, transport and beer make it a very reasonable investment.</description>
    </item>
    
    <item>
      <title>Book review: Antifragile</title>
      <link>https://jefclaes.be/2013/12/book-review-antifragile.html</link>
      <pubDate>Sun, 08 Dec 2013 17:30:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/12/book-review-antifragile.html</guid>
      <description>When things are fragile, they break easily. We often see fragility as a bad thing and design things to be robust. But this isn&amp;rsquo;t what we&amp;rsquo;re really after either; things that are robust might be hard to break, but they&amp;rsquo;re also hard to change, making them fail to adapt to new stressors over time. The model that we&amp;rsquo;re really after is antifragility; when something is antifragile it will benefit from stressors and get better over time.</description>
    </item>
    
    <item>
      <title>Observations over assumptions</title>
      <link>https://jefclaes.be/2013/11/observations-over-assumptions.html</link>
      <pubDate>Sun, 24 Nov 2013 18:08:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/11/observations-over-assumptions.html</guid>
      <description>I heard a story once about an engineer who worked on the Disneyland site when it opened in Anaheim, CA in 1955. A month before the park opened, the new grass and sod were being applied to the grounds as one of the last items to be completed before the big grand opening. The parking lot was some distance from the park&amp;rsquo;s gates and required a lot of turf. However, the sidewalks had not been planned or constructed to accommodate patterns.</description>
    </item>
    
    <item>
      <title>Event storming workshop slides</title>
      <link>https://jefclaes.be/2013/11/event-storming-workshop-slides.html</link>
      <pubDate>Sun, 17 Nov 2013 19:56:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/11/event-storming-workshop-slides.html</guid>
      <description>At Euricom, we quarterly all retreat to headquarters for a day of sharing and learning. This time, I and others organized and facilitated an event storming workshop.
After a short introduction on event storming participants were initiated to the domain of Cambio CarSharing - which is packed with behaviour. After that, seven groups of five (+ one domain expert) spread out across the office, and spent two slots of twenty minutes modeling the domain - with two extra slots for feedback.</description>
    </item>
    
    <item>
      <title>An event store with optimistic concurrency</title>
      <link>https://jefclaes.be/2013/11/an-event-store-with-optimistic.html</link>
      <pubDate>Sun, 10 Nov 2013 18:25:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/11/an-event-store-with-optimistic.html</guid>
      <description>Like I mentioned last week - after only five posts on the subject - there still are a great deal of event sourcing nuances left to be discovered.
My current event store implementation only supports a single user. Due to an aggressive file lock, concurrently accessing an aggregate will throw an exception. Can we allow multiple users to write to and read from an event stream? Also, what can we do about users making changes to the same aggregate; can we somehow detect conflicts and avoid changes to be committed?</description>
    </item>
    
    <item>
      <title>Event source all the things?</title>
      <link>https://jefclaes.be/2013/11/event-source-all-things.html</link>
      <pubDate>Sun, 03 Nov 2013 18:45:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/11/event-source-all-things.html</guid>
      <description>Having covered projections last week, I think I have come full circle in these posts that turned out to be a small preliminary series on event sourcing. Even though there are still a vast amount of nuances to discover, I think I&amp;rsquo;ve captured the gist of it. Even without running an event sourced system in production - I feel as if I somewhat have an idea of what event sourcing can bring to the table.</description>
    </item>
    
    <item>
      <title>Event projections</title>
      <link>https://jefclaes.be/2013/10/event-projections.html</link>
      <pubDate>Sun, 27 Oct 2013 17:43:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/10/event-projections.html</guid>
      <description>In my first two posts on event sourcing, I implemented an event sourced aggregate from scratch. After being able to have an aggregate record and play events, I looked at persisting them in an event store. Logically, the next question is: how do I query my aggregates, how do I get my state out?
In traditional systems, write and read models are not separated, they are one and the same. Event sourced systems on the other hand have a write model - event streams, and a separate read model.</description>
    </item>
    
    <item>
      <title>An event store</title>
      <link>https://jefclaes.be/2013/10/an-event-store.html</link>
      <pubDate>Sun, 20 Oct 2013 17:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/10/an-event-store.html</guid>
      <description>Last week, I implemented an event sourced aggregate from scratch. There I learned, that there isn&amp;rsquo;t much to a naively implemented event sourced aggregate; it should be able to initialize itself from a stream of events, and it should be able to record all the events it raises.
public interface IEventSourcedAggregate : IAggregate { void Initialize(EventStream eventStream); EventStream RecordedEvents(); } The question I want to answer today is: how do I persist those event sourced aggregates?</description>
    </item>
    
    <item>
      <title>An event sourced aggregate</title>
      <link>https://jefclaes.be/2013/10/an-event-sourced-aggregate.html</link>
      <pubDate>Sun, 13 Oct 2013 18:36:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/10/an-event-sourced-aggregate.html</guid>
      <description>Last week I shared my theoretical understanding of event sourcing. Today, I want to make an attempt at making that theory tangible by implementing an event sourced aggregate.
In traditional systems, we only persist the current state of an object.

In event sourced systems, we don&amp;rsquo;t persist the current state of an object, but the sequence of events that caused the object to be in the current state.</description>
    </item>
    
    <item>
      <title>My understanding of event sourcing</title>
      <link>https://jefclaes.be/2013/10/my-understanding-of-event-sourcing.html</link>
      <pubDate>Sun, 06 Oct 2013 18:32:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/10/my-understanding-of-event-sourcing.html</guid>
      <description>I&amp;rsquo;ve been studying event sourcing from a distance for little over a year now; reading online material and going through some of the excellent OS code. Unfortunately, there would be no value introducing it into my current project - it would even be a terrible idea, so I decided to satisfy my inquisitiveness by consolidating and sharing my understanding of the concept.
Domain events An event is something that happened in the past.</description>
    </item>
    
    <item>
      <title>CZ The Trilogy</title>
      <link>https://jefclaes.be/2013/09/cz-trilogy.html</link>
      <pubDate>Sun, 29 Sep 2013 18:15:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/09/cz-trilogy.html</guid>
      <description>Over the weekend, we visited the Czech Republic for the third time (one and two). It&amp;rsquo;s mostly chance that sends us that way every time though. This time, we were invited by friends to accompany them in staying over at their family&amp;rsquo;s house - who made it their job to lead guided tours through Prague.
We left Thursday right after work, hoping to get there in eight hours. A decent traffic jam, a missed exit, and some bad map reading decided otherwise; it added three hours to the trip.</description>
    </item>
    
    <item>
      <title>Actor Model in COBOL</title>
      <link>https://jefclaes.be/2013/09/actor-model-in-cobol.html</link>
      <pubDate>Sun, 22 Sep 2013 16:38:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/09/actor-model-in-cobol.html</guid>
      <description>In an Actor system, each Actor acts as a self-contained and autonomous component. An Actor can only communicate with other Actors by exchanging messages - they are not allowed to share state. Messages are handled asynchronously, and are nondeterministic. The location of Actors should be transparent; they can either live on the same machine, or on a distributed system. These properties make the Actor Model a great fit for parallel and distributed computing.</description>
    </item>
    
    <item>
      <title>Slides from my talk on the Ubiquitous Language</title>
      <link>https://jefclaes.be/2013/09/slides-from-my-talk-on-ubiquitous.html</link>
      <pubDate>Sun, 15 Sep 2013 16:34:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/09/slides-from-my-talk-on-ubiquitous.html</guid>
      <description>I just returned from our yearly Euricom retreat. This year, all forty of us got to spend four days in the South of Spain. Where we had longish sessions and a few workshops last year, we experimented with shorter talks this year - a la lightning talks, TEDx style.
This format made it possible for everyone to speak, but also forced the speaker to keep the scope of the talk focused, and to organize the information in a way that attendees can get the gist of it in only twelve minutes.</description>
    </item>
    
    <item>
      <title>The first DDDBE Modellathon</title>
      <link>https://jefclaes.be/2013/09/the-first-dddbe-modellathon.html</link>
      <pubDate>Fri, 06 Sep 2013 13:24:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/09/the-first-dddbe-modellathon.html</guid>
      <description>On our way back from DDD Exchange, heavily influenced by yet another immersive DDD experience, we searched for ways to keep the momentum going. Sure, we met up regularly for CQRS beers, but we felt that we could do more, better. That&amp;rsquo;s when we coined the term modellathon, something like a hackathon, but instead of writing code, we would build models.
Thanks to the effort of Mathias, Stijn and Yves, Tuesday marked the first get-together of the Belgian DDD user group in its official form.</description>
    </item>
    
    <item>
      <title>Inheritance is like Jenga</title>
      <link>https://jefclaes.be/2013/08/inheritance-is-like-jenga.html</link>
      <pubDate>Sun, 25 Aug 2013 18:18:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/08/inheritance-is-like-jenga.html</guid>
      <description>These last few days, I have been working on a piece of our codebase that accidentally got very inheritance heavy.
When it comes to inheritance versus composition, there are a few widely accepted rules of thumb out there. While prefer composition over inheritance doesn&amp;rsquo;t cover the nuances, it&amp;rsquo;s not terrible advice; composition will statistically often be the better solution. Steve McConnell&amp;rsquo;s composition defines a &amp;lsquo;has a&amp;rsquo;- relationship while inheritance defines an &amp;lsquo;is a&amp;rsquo;-relationship, gives you a more nuanced and simple tool to apply to a scenario.</description>
    </item>
    
    <item>
      <title>But I already wrote it</title>
      <link>https://jefclaes.be/2013/08/but-i-already-wrote-it.html</link>
      <pubDate>Sun, 18 Aug 2013 16:24:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/08/but-i-already-wrote-it.html</guid>
      <description>A few weeks ago, we set out to implement a feature that enabled back office users to set a new rate ahead of time. With our analyst and the involved user being out of the office for days, we had to solely rely on written requirements. Two of us skimmed the documents, but didn&amp;rsquo;t take the time to assure there wasn&amp;rsquo;t any ambiguity - it looked trivial really. I went back to what I was doing, while my colleague set out to implement this feature.</description>
    </item>
    
    <item>
      <title>Eventual consistent domain events with RavenDB and IronMQ</title>
      <link>https://jefclaes.be/2013/08/eventual-consistent-domain-events-with.html</link>
      <pubDate>Thu, 15 Aug 2013 14:03:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/08/eventual-consistent-domain-events-with.html</guid>
      <description>Working on side projects, I often find myself using RavenDB for storage and IronMQ for queueing. I wrote about that last one before here and here.
One project I&amp;rsquo;m working on right now makes use of domain events. As an example, I&amp;rsquo;ll use the usual suspect: the BookingConfirmed event. When a booking has been confirmed, I want to notify my customer by sending him an email.
I want to avoid that persisting a booking fails because an eventhandler throws - the mail server is unavailable.</description>
    </item>
    
    <item>
      <title>When your commands spell CUD</title>
      <link>https://jefclaes.be/2013/08/when-your-commands-spell-cud.html</link>
      <pubDate>Sun, 04 Aug 2013 19:08:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/08/when-your-commands-spell-cud.html</guid>
      <description>A good while ago, I blogged on commands (and queries). After exploring various flavors, I eventually settled on this one; commands, handlers and an in-memory bus that serves as a command executor.
Commands help you in supporting the ubiquitous language by explicitly capturing user intent at the boundaries of your system - think use cases. You can look at them as messages that are being sent to your domain. In this regard, they also serve as a layer over your domain - decoupling the inside from the outside, allowing you to gradually introduce concepts on the inside, without breaking the outside.</description>
    </item>
    
    <item>
      <title>The last cowboy</title>
      <link>https://jefclaes.be/2013/07/to-live-die-in-la.html</link>
      <pubDate>Tue, 16 Jul 2013 05:46:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/07/to-live-die-in-la.html</guid>
      <description>After seventeen days, 2000 miles (3220km), seven states, eight national parks and fifteen motels, our second USA road trip has come to an end. Inspired, and with new insights, we&amp;rsquo;re leaving for Belgium in the morning.
Along the way, we documented our journey in these posts:
 To Live &amp;amp; Die in L.A Fireworks, Tequila and Silvertown Blues She said yes! Stairway to heaven The long highway The road goes on forever  Thanks for reading!</description>
    </item>
    
    <item>
      <title>The road goes on forever</title>
      <link>https://jefclaes.be/2013/07/the-road-goes-on-forever.html</link>
      <pubDate>Mon, 15 Jul 2013 04:51:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/07/the-road-goes-on-forever.html</guid>
      <description>We didn’t get to see a lot of Salt Lake City. Before heading to Idaho Falls, we hung around at the mall, feasted on Sushi, and bought new hiking shoes since ours literally fell apart.
Since Idaho Falls just served as a launching point to Yellowstone, we filled the hole in our schedule with a date night; we had BBQ and went to see WorldWar Z.
After another long drive the next day, we exchanged the dirt for greener scenery.</description>
    </item>
    
    <item>
      <title>The long highway</title>
      <link>https://jefclaes.be/2013/07/the-long-highway.html</link>
      <pubDate>Fri, 12 Jul 2013 07:13:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/07/the-long-highway.html</guid>
      <description>We’re past halfway our trip and we need to make headway if we want to stay on schedule and reach Yellowstone by Sunday. Long, but pleasant drives; if you’re used to Belgian traffic.
Yesterday we visited Capitol Reef National Park. We originally planned on doing the Hickman Bridge Trail, but apparently there had recently been a big rock fall, blocking access at the trailhead. As an alternative we did the Narrows trail at Grand Wash Road, which was carved by a stream ages ago and is now still sometimes victim to flashfloods.</description>
    </item>
    
    <item>
      <title>Stairway to heaven</title>
      <link>https://jefclaes.be/2013/07/stairway-to-heaven.html</link>
      <pubDate>Wed, 10 Jul 2013 07:04:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/07/stairway-to-heaven.html</guid>
      <description>These last two days have been rather tiring. Yesterday we drove up to Bryce Canyon, where we did the Queen’s Garden and Navajo Loop hike, which was only 3 miles (5km) but was rather strenuous because the trail takes you all the way down and all the way up again.


Today we followed the advice of the kind lady at the visitor center and hiked along Calfs Creek. It was a 6 miles (10km) round trip through loose sand in over 100°F (38°C), but halfway you’re rewarded with a stunningly beautiful waterfall and a refreshing dip in the basin.</description>
    </item>
    
    <item>
      <title>She said yes!</title>
      <link>https://jefclaes.be/2013/07/she-said-yes.html</link>
      <pubDate>Tue, 09 Jul 2013 07:42:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/07/she-said-yes.html</guid>
      <description>Since our stay in Vegas was rather short, we selected some things we failed to do last time. For me, shooting a gun was definitely on that list. Although I&amp;rsquo;m not that big on gun culture - seems to me that if you live by the gun, you&amp;rsquo;re more likely to die by the gun - it&amp;rsquo;s still a thrill holding such a powerful weapon. We headed to Vegas&amp;rsquo;s most popular shooting range: The Gun Store.</description>
    </item>
    
    <item>
      <title>Fireworks, Tequila and Silvertown Blues</title>
      <link>https://jefclaes.be/2013/07/fireworks-tequila-and-silvertown-blues.html</link>
      <pubDate>Sun, 07 Jul 2013 06:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/07/fireworks-tequila-and-silvertown-blues.html</guid>
      <description>After a strenuous drive from Los Angeles to San Diego, we took advantage of the mild climate to unwind at San Diego’s Aquatica.
Being the 4thof July, we joined the festivities and watched the fireworks from the car. Sadly we didn’t get to see a redo of last year’s spectacle, when San Diego accidentally launched all its fireworks in 30 seconds.

Next we headed for Joshua Tree National Park. With temperatures flirting with 100°F (38°C), we took on one small hike and drove up to two viewpoints; Skull Rock and Key’s View.</description>
    </item>
    
    <item>
      <title>To Live &amp; Die in L.A.</title>
      <link>https://jefclaes.be/2013/07/to-live-die-in-la.html</link>
      <pubDate>Thu, 04 Jul 2013 08:51:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/07/to-live-die-in-la.html</guid>
      <description>After exploring the USA’s West Coast two years ago, we felt like we had to pay a second visit to fill in some blanks.
We left Antwerp Sunday 7AM to touch down 25 hours later in LAX, after an eight hour cross-Atlantic flight to Newark and a six hour overlay waiting for a connecting flight.
We were welcomed by a rental car salesman who strongly advised us to upgrade to a bigger SUV which would give us tinted windows since it’s gonna be hot, you know.</description>
    </item>
    
    <item>
      <title>Multiplayer Enterprise Architect</title>
      <link>https://jefclaes.be/2013/06/multiplayer-enterprise-architect.html</link>
      <pubDate>Sun, 30 Jun 2013 17:00:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/06/multiplayer-enterprise-architect.html</guid>
      <description>Hanging around in the pub after DDDX, I ended up talking to Alberto Brandolini. For those who have never met him; he&amp;rsquo;s very much into visualization. You will always see him carrying a drawing pad, with a dash of permanent marker on his cheek, and a few lost sticky notes on his back. I don&amp;rsquo;t know if it was the Italian accent and the strong gestures, or my mildly intoxicated condition, but the idea of visualization as an important tool grew on me even more that evening.</description>
    </item>
    
    <item>
      <title>Not handling edge cases, making them explicit instead</title>
      <link>https://jefclaes.be/2013/06/not-handling-edge-cases-making-them.html</link>
      <pubDate>Sun, 23 Jun 2013 16:49:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/06/not-handling-edge-cases-making-them.html</guid>
      <description>When I wrote about accidental entities earlier, we followed a consultant building software for a car rental company. In the meanwhile, he has finished implementing the registration of new cars. Next on the list is allowing customers to make a booking.
We managed to get the CEO to set a whole hour apart to walk us over how the booking system should work.
 CEO: &amp;ldquo;I&amp;rsquo;m not sure this meeting is going to take a whole hour though.</description>
    </item>
    
    <item>
      <title>Angular.js and IE8 caching</title>
      <link>https://jefclaes.be/2013/06/angularjs-and-ie8-caching.html</link>
      <pubDate>Sun, 09 Jun 2013 16:52:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/06/angularjs-and-ie8-caching.html</guid>
      <description>Older Internet Explorer versions are notorious for agressively caching AJAX requests. In this post, you&amp;rsquo;ll find two techniques that combat this behaviour.
The first option is to have your server explicitly set the caching headers.
Response.Cache.SetExpires(DateTime.UtcNow.AddDays(-1)); Response.Cache.SetValidUntilExpires(false); Response.Cache.SetRevalidation(HttpCacheRevalidation.AllCaches); Response.Cache.SetCacheability(HttpCacheability.NoCache); Response.Cache.SetNoStore(); Since you don&amp;rsquo;t necessarily own the server, or clients might already have cached some requests, you can trick the browser into thinking each request is a fresh one by making each url unique.</description>
    </item>
    
    <item>
      <title>Accidental entities - what about the UI?</title>
      <link>https://jefclaes.be/2013/06/accidental-entities-what-about-ui.html</link>
      <pubDate>Sun, 02 Jun 2013 16:24:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/06/accidental-entities-what-about-ui.html</guid>
      <description>This post is a follow-up to my previous blog post &amp;ldquo;Accidental entities - you don&amp;rsquo;t need that identity&amp;quot;.
In that post, we followed a consultant building an application for a car rental. One of the requirements was that the CEO could manage a collection of available colors. Although the tools at our disposal - a relational database and NHibernate - wanted to trick us into making a car reference one of these available colors by its identifier, we found out that the CEO really thinks of a car&amp;rsquo;s color as a value, and does not care about a color&amp;rsquo;s identity.</description>
    </item>
    
    <item>
      <title>Accidental entities - you don&#39;t need that identity</title>
      <link>https://jefclaes.be/2013/05/accidental-entities-you-dont-need-that.html</link>
      <pubDate>Sun, 26 May 2013 16:27:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/05/accidental-entities-you-dont-need-that.html</guid>
      <description>An entity is identified by an identifier, while value objects are identified by their value.
If I make a living renting cars to tourists, I might not care the least about the identity of the colors the cars came in. I just care about their value; Rosso Corsa, Azurro Metallic&amp;hellip; If I repaint the car, the color changes, and the previous color is abandoned as a whole.
However, if I were a car paint manufacturer, I would care a great deal about the identity of a color.</description>
    </item>
    
    <item>
      <title>Validating composite models with knockout validation</title>
      <link>https://jefclaes.be/2013/05/validating-composite-models-with.html</link>
      <pubDate>Mon, 20 May 2013 17:02:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/05/validating-composite-models-with.html</guid>
      <description>When you use knockout validation to extend observables with validation rules, it will add a few functions to these observables - the most important ones being; error and isValid. You can use these functions to verify if any of the validation rules were violated, and to extract an error message.
To extract all of the error messages out of a composite model, you can use a grouping function.
function BookingModel() { var self = this; self.</description>
    </item>
    
    <item>
      <title>IDDD Tour notes (2/2)</title>
      <link>https://jefclaes.be/2013/05/iddd-tour-notes-22.html</link>
      <pubDate>Sun, 12 May 2013 15:44:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/05/iddd-tour-notes-22.html</guid>
      <description>This is the second and last part of my notes I scribbled down attending the IDDD Tour. The first part was published last week.
A better model  Even if you come up with a better model, the fact that it has been the ubiquitous language of the domain for decades proves that it works for them.
 This quote bothers me a bit. There definitely is truth to this, but modeling an existing process often presents such a great opportunity to revise and improve it.</description>
    </item>
    
    <item>
      <title>IDDD Tour notes (1/2)</title>
      <link>https://jefclaes.be/2013/05/iddd-tour-notes-12.html</link>
      <pubDate>Sun, 05 May 2013 17:10:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/05/iddd-tour-notes-12.html</guid>
      <description>Two weeks ago I got to spend four days attending the IDDD Tour by Vaughn Vernon. Although my book queue has only allowed me to shallowly browse the book, I had high hopes for this course. I anticipated a week of getting lectured on DDD with a few practical exercises, but was blown away by the openness and interaction promoted by Vaughn and his associate Alberto Brandolini. A passionate group, engaging workshops, long days and lots of sharing made these few days exceptionally satisfying and inspirational.</description>
    </item>
    
    <item>
      <title>Designing entities: immutability first</title>
      <link>https://jefclaes.be/2013/04/designing-entities-immutability-first.html</link>
      <pubDate>Sun, 07 Apr 2013 17:35:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2013/04/designing-entities-immutability-first.html</guid>
      <description>The first year I wrote software for a living I spent my days mostly writing forms over data applications; most of my efforts were wasted just trying to make things work using ASP.NET and the Webforms engine. It was only after a year and graduating from the School of Hard Knocks that I learned there is a lot more to building clean and maintainable software than knowing the ins&amp;rsquo; and outs&amp;rsquo; of a proprietary UI technology.</description>
    </item>
    
    <item>
      <title>Reading large files in chunks with proper encapsulation</title>
      <link>https://jefclaes.be/2013/03/reading-large-files-in-chunks-with.html</link>
      <pubDate>Sun, 24 Mar 2013 18:16:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/03/reading-large-files-in-chunks-with.html</guid>
      <description>I&amp;rsquo;ve been doing some work lately which involves sequentially reading large files (&amp;gt; 2 to 5GB). This entails that it&amp;rsquo;s not an option to read the whole structure in memory; it&amp;rsquo;s more reliable to process the file in chunks. I occasionally come across legacy that solves exactly this problem, but in a procedural way, resulting in tangled spaghetti. To be honest, the first piece of software I ever wrote in a professional setting also went at it in the wrong way.</description>
    </item>
    
    <item>
      <title>Putting my IronMQ experiment under stress</title>
      <link>https://jefclaes.be/2013/03/putting-my-ironmq-experiment-under.html</link>
      <pubDate>Sun, 17 Mar 2013 16:10:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/03/putting-my-ironmq-experiment-under.html</guid>
      <description>Two weeks ago, I shared my first impressions of IronMQ. Last week, I looked at some infrastructure to facilitate pulling from IronMQ. This implementation worked, but I hadn&amp;rsquo;t put it under stress yet; &amp;ldquo;First make it work, then make it fast&amp;rdquo;, and all of that.
I arranged a simple scenario for testing: one message type - thus one queue, where there are eight queue consumers that simultaneously pull messages from that queue, and dispatch them to a handler which sleeps for one second.</description>
    </item>
    
    <item>
      <title>Some experimental infrastructure for IronMQ pull </title>
      <link>https://jefclaes.be/2013/03/some-experimental-infrastructure-for.html</link>
      <pubDate>Sun, 10 Mar 2013 17:29:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/03/some-experimental-infrastructure-for.html</guid>
      <description>I wrote about using IronMQ as a cloud-based message queue last week. In that post I explained that you can go at using IronMQ in two ways; either you pull from the queue yourself, or you let IronMQ push messages from the queue to your HTTP endpoints. At first sight, the latter allows you to outsource more infrastructure to their side, but upon closer inspection it also introduces other concerns: security, local debugging and scalability.</description>
    </item>
    
    <item>
      <title>First IronMQ impressions</title>
      <link>https://jefclaes.be/2013/03/first-ironmq-impressions.html</link>
      <pubDate>Sun, 03 Mar 2013 16:45:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/03/first-ironmq-impressions.html</guid>
      <description>First time I touched messaging was in the first few years of my professional life working on software that supported fire departments in their day-to-day activities. The dispatching software would send messages to a proprietary broker, which in its turn would forward them to interested subscribers; other dispatching clients, or services. To ensure availability, the broker component could failover to a different machine, but that was about it. It didn&amp;rsquo;t allow you to queue or retry messages; if you weren&amp;rsquo;t up when the messages were forwarded, you would never receive them.</description>
    </item>
    
    <item>
      <title>My Christmas holiday project postmortem</title>
      <link>https://jefclaes.be/2013/02/my-christmas-holiday-project-postmortem.html</link>
      <pubDate>Sun, 24 Feb 2013 16:42:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/02/my-christmas-holiday-project-postmortem.html</guid>
      <description>Somewhere over a year and a half ago I discovered the music of Dire Straits, which has sparked a fanatical love and fascination for the guitar in me, and basically for every piece of music Mark Knopfler has ever touched (*). A year ago, I finally had the courage to pick up the guitar myself. Not sure if I&amp;rsquo;d stick with it, I made an uninformed purchase of a rather inexpensive Squier Jazzmaster, just because it somewhat resembled the real object of desire, a Fender Stratocaster.</description>
    </item>
    
    <item>
      <title>Adding the R to CQS: some storage options</title>
      <link>https://jefclaes.be/2013/02/adding-r-to-cqs-some-storage-options.html</link>
      <pubDate>Sun, 17 Feb 2013 17:57:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/02/adding-r-to-cqs-some-storage-options.html</guid>
      <description>I&amp;rsquo;ve been writing quite a bit about CQS (or command and query separation) lately. In my last post on using events, I already hinted towards bringing in the R; command and query responsibility separation.
With CQS, commands can mutate data, while queries can only read that data. CQRS takes this one step further, and assigns commands and queries each a dedicated model; we now talk of a write side, and a read side.</description>
    </item>
    
    <item>
      <title>Premature judgement</title>
      <link>https://jefclaes.be/2013/02/premature-judgment.html</link>
      <pubDate>Sun, 10 Feb 2013 16:46:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/02/premature-judgment.html</guid>
      <description>When I started my first job, I hardly ever judged my peers. After all, how could I? Everything was unknown for me; I couldn&amp;rsquo;t differentiate good from bad. Over the years that has changed a bit, but with that, I&amp;rsquo;ve also slowly become more judgemental towards peers, often prematurely, and not always deservedly.
The first few months of last year, I found myself doing maintenance on a legacy code base between projects.</description>
    </item>
    
    <item>
      <title>Raising events in commandhandlers</title>
      <link>https://jefclaes.be/2013/02/raising-events-in-commandhandlers.html</link>
      <pubDate>Sun, 03 Feb 2013 17:49:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/02/raising-events-in-commandhandlers.html</guid>
      <description>I&amp;rsquo;ve explored quite a few options on how to handle commands and queries in the last few posts. I finally settled on this approach. The example used in that post looked like this.
public class CreateSubscriptionCommandHandler : ICommandHandler&amp;lt;CreateSubscriptionCommand&amp;gt; { private IDocumentSession _session; public CreateSubscriptionCommandHandler(IDocumentSession session) { _session = session; } public void Handle(CreateSubscriptionCommand command) { var subscription = new Documents.Subscription( command.Value, command.Category, command.EmailAddress); _session.Store(subscription); } } Now imagine I would want to do some extra stuff after creating the subscription; update the sales statistics, append the email address to a mailing list, send out a confirmation email, etc.</description>
    </item>
    
    <item>
      <title>Organizing commands and queries</title>
      <link>https://jefclaes.be/2013/01/organizing-commands-and-queries.html</link>
      <pubDate>Sun, 27 Jan 2013 18:23:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/01/organizing-commands-and-queries.html</guid>
      <description>In the last few posts I settled on an architecture for handling commands and queries. A byproduct of the described approach, is that your codebase quickly racks up plentiful little classes; a class to hold data, and a handler to act on that data, for each use case.
There are a few ways you can go at organizing things.
Everything in one location When there is very little going on in your application, you can just dump everything in one location without getting hurt too much.</description>
    </item>
    
    <item>
      <title>RavenDB: Drop all collections</title>
      <link>https://jefclaes.be/2013/01/ravendb-drop-all-collections.html</link>
      <pubDate>Thu, 24 Jan 2013 20:08:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/01/ravendb-drop-all-collections.html</guid>
      <description>I never stub or mock the database when I&amp;rsquo;m using RavenDB. Generally, I use an embeddable documentstore running in memory, and initialize a new instance on every test. However, I like to run some stress tests against a real instance, and here I found myself wanting to wipe clean the state of previous tests, without having to create a new database (which is rather slow).
First I create the default DocumentsByEntityName index to make sure it&amp;rsquo;s there - it normally gets created when you open the studio for the first time.</description>
    </item>
    
    <item>
      <title>Separating command data from logic and sending it on a bus</title>
      <link>https://jefclaes.be/2013/01/separating-command-data-from-logic-and.html</link>
      <pubDate>Sun, 20 Jan 2013 22:03:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/01/separating-command-data-from-logic-and.html</guid>
      <description>In my first post on this topic, I started out with an attempt to limit abstractions to solely commands and queries. Commands and queries were self-contained and could be invoked by passing them to a context-providing generic handler. The drawback of this approach was that it made constructor dependency injection impossible. In a next post, I separated data from logic, but never got around to writing a dispatcher that associates command data with their handlers.</description>
    </item>
    
    <item>
      <title>Self-contained commands with dependencies </title>
      <link>https://jefclaes.be/2013/01/self-contained-commands-with.html</link>
      <pubDate>Sun, 13 Jan 2013 18:17:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2013/01/self-contained-commands-with.html</guid>
      <description>Also read: separating command data from logic and sending it on a bus
In October I looked at an architecture that limits abstractions to solely commands and queries. In that post, I had some infrastructure that looked like this.
public abstract class Command { public abstract void Execute(); } public abstract class Query&amp;lt;T&amp;gt; { public abstract T Execute(); } public interface ICommandHandler { void Execute(Command command); } public class CommandHandler : ICommandHandler { public void Execute(Command command) { command.</description>
    </item>
    
    <item>
      <title>2012 Annual Review</title>
      <link>https://jefclaes.be/2012/12/2012-annual-review.html</link>
      <pubDate>Mon, 31 Dec 2012 15:58:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/12/2012-annual-review.html</guid>
      <description>It&amp;rsquo;s that time of the year again where I take some time to look back on the year passed and peek at the year ahead. This is mostly a post I like to write up for myself, forcing reflection.
The biggest personal changes this year were moving out of my parents&amp;rsquo; place, and my girlfriend&amp;rsquo;s decision to study medicine after graduating as a Master of Arts earlier this year. I had no idea how things would turn out once we lived together, but so far we have been doing great.</description>
    </item>
    
    <item>
      <title>2012&#39;s most read posts</title>
      <link>https://jefclaes.be/2012/12/2012s-most-read-posts.html</link>
      <pubDate>Sun, 23 Dec 2012 15:53:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/12/2012s-most-read-posts.html</guid>
      <description>I look forward to writing this post each year; it&amp;rsquo;s by far the easiest one to write, and it provides me with an occasion to look back on previous years (2009, 2010, 2011). It&amp;rsquo;s entertaining - and shameful too - to see what kept me busy back then, which opinions I held, and which technologies and techniques are still relevant in the meanwhile. Anyways, here it goes.
The most read post this year, with 37.</description>
    </item>
    
    <item>
      <title>It&#39;s not cake we are baking</title>
      <link>https://jefclaes.be/2012/12/its-not-cake-we-are-baking.html</link>
      <pubDate>Sun, 09 Dec 2012 16:08:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/12/its-not-cake-we-are-baking.html</guid>
      <description>I recently watched a talk on Vimeo where Christin Gorman talks about how cookie dough relates to Hibernate; why use the generic, bloated and one-fits-all solution when you can mix together your own yummy cookie dough? We should aspire to be the Gordon Ramsey of software, not the college student who can only cook Ramen noodles. If you haven&amp;rsquo;t watched or listened to her talk, you should; it&amp;rsquo;s only a few minutes long, and she brings it really well.</description>
    </item>
    
    <item>
      <title>Some notes on performance tuning with NHibernate</title>
      <link>https://jefclaes.be/2012/12/some-notes-on-performance-tuning-with.html</link>
      <pubDate>Sun, 02 Dec 2012 17:36:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/12/some-notes-on-performance-tuning-with.html</guid>
      <description>A few weeks back, I spent an intensive day performance tuning parts of a, to me, relatively unfamiliar part of our codebase. Like it often is, the biggest optimizations were to be found in how we work with the database. Now, I don&amp;rsquo;t consider myself to be an NHibernate expert; I read this book and have used it on two projects, but in the end I just do my best to avoid doing stupid things with it.</description>
    </item>
    
    <item>
      <title>Released: Kill long meetings</title>
      <link>https://jefclaes.be/2012/11/released-kill-long-meetings.html</link>
      <pubDate>Sun, 25 Nov 2012 17:45:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/11/released-kill-long-meetings.html</guid>
      <description>A lot has already been said and written about meetings, and some have carried the message above par; &amp;lsquo;Meetings: where work goes to die&#39;. Today, I&amp;rsquo;m not going to foul the internet with another rant, but I&amp;rsquo;d like to show you a small application built over the last few weeks after work.
I regularly find myself building small things as an antitoxin to the regular periods of not writing and shipping code at work.</description>
    </item>
    
    <item>
      <title>Commuting? Have you done the math?</title>
      <link>https://jefclaes.be/2012/11/commuting-have-you-done-math.html</link>
      <pubDate>Sun, 04 Nov 2012 20:24:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/11/commuting-have-you-done-math.html</guid>
      <description>On my first job interview, over four years ago, I was asked whether I would relocate if I was hired. Back then, I still lived in the Campine region with my parents, while the Ferranti Computer Systems headquarters are in Antwerp. I thought about it for a few seconds and told the interviewer that I didn&amp;rsquo;t plan on moving out of my parents&amp;rsquo; place in the first few years. Besides, the distance isn&amp;rsquo;t that great; it&amp;rsquo;s only 60km (=37 miles) of highway, how bad could it be?</description>
    </item>
    
    <item>
      <title>Post Web.NET Europe</title>
      <link>https://jefclaes.be/2012/10/post-webnet-europe.html</link>
      <pubDate>Mon, 22 Oct 2012 20:35:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/10/post-webnet-europe.html</guid>
      <description>I attended and spoke at Web.NET Europe in Milan over the weekend. This was only my fourth full day- or more conference (Techdays Belgium, TechEd Berlin and HTML5 WebCamps), but it was undoubtedly the best one so far.
The quality of the sessions was definitely not inferior to those of bigger conferences. I especially enjoyed the talks on SignalR, OAuth and scaling data (I included some of my notes below). The strength of this conference doesn&amp;rsquo;t lie in the exceptional speakers or sessions though, but in its cozy size and the type of attendees it attracts.</description>
    </item>
    
    <item>
      <title>Slides and code from my Web.NET Europe REST and ASP.NET Web API session</title>
      <link>https://jefclaes.be/2012/10/slides-and-code-from-my-webnet-europe.html</link>
      <pubDate>Sun, 21 Oct 2012 00:16:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/10/slides-and-code-from-my-webnet-europe.html</guid>
      <description>I just returned to the hotel after attending and speaking at Web.NET Europe 2012. There were multiple sessions on ASP.NET Web API today, and I was responsible for delivering the first one of the day. Being first, and to avoid overlap with others, I tried to lay a solid foundation by focusing on the REST and ASP.NET Web API basics: resources, identifiers, representations, verbs and hypermedia.
More people than I expected showed up for my talk; somewhere around 50 to 70 attendees, I guess.</description>
    </item>
    
    <item>
      <title>Commands with dependencies</title>
      <link>https://jefclaes.be/2012/10/commands-with-dependencies.html</link>
      <pubDate>Mon, 15 Oct 2012 16:57:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/10/commands-with-dependencies.html</guid>
      <description>Also read: Separating command data from logic and sending it on a bus
Yesterday I wrote about an architecture which limits abstractions by solely introducing commands and queries. I shared a dead simple variation of this pattern, the advantages I experienced, and how I could still unit test the controller if I wanted to. At the end of that post I wondered how I would be able to test commands in isolation; suppose the implementation doesn&amp;rsquo;t use a database this time, but a hairy, too low-level, third party webservice.</description>
    </item>
    
    <item>
      <title>Commands, queries and testing</title>
      <link>https://jefclaes.be/2012/10/commands-queries-and-testing.html</link>
      <pubDate>Sun, 14 Oct 2012 17:45:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/10/commands-queries-and-testing.html</guid>
      <description>Also read:
 Self-contained commands with dependencies Separating command data from logic and sending it on a bus  We need abstraction, but the amount of abstraction we really need depends, and should be assessed on a case-by-case basis. It seems advisable to grow abstractions, and to introduce them gradually.
That being said, in this post I want to talk about an architecture that tries to limit abstractions to solely commands and queries.</description>
    </item>
    
    <item>
      <title>Côte d&#39;Opale</title>
      <link>https://jefclaes.be/2012/10/cote-dopale.html</link>
      <pubDate>Mon, 08 Oct 2012 21:51:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/10/cote-dopale.html</guid>
      <description>The girlfriend, me and another couple, returned from a short weekend at the French Opal Coast yesterday evening. Although we only planned this trip a week in advance, we still failed to anticipate how erratic the weather can be in October; setting up camp in the dark, on a sloughy underground, with a soft drizzle on your back, isn&amp;rsquo;t my idea of fun after a long day at work. The next morning, with destination Cape Blanc Nez, we drove over coastal routes between vast green fields, towards clearer skies.</description>
    </item>
    
    <item>
      <title>On job titles</title>
      <link>https://jefclaes.be/2012/10/on-job-titles.html</link>
      <pubDate>Sun, 07 Oct 2012 19:22:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/10/on-job-titles.html</guid>
      <description>It didn&amp;rsquo;t take long before I noticed how little job titles mean. In my first job, you were assured to be granted a fancy title after only having acquired a minimum seniority, if you knew how to play the game. A more important sounding job title was HR&amp;rsquo;s default bribe that often kept people from leaving for greener pastures, for a short while. But even after being upgraded from a stable cleaner to a Senior Barn Hygiene Technician, you&amp;rsquo;re still cleaning shit though.</description>
    </item>
    
    <item>
      <title>The 7 R&#39;s of Hypermedia</title>
      <link>https://jefclaes.be/2012/09/the-7-rs-of-hypermedia.html</link>
      <pubDate>Mon, 17 Sep 2012 21:42:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/09/the-7-rs-of-hypermedia.html</guid>
      <description>While most REST concepts are rather easy to grok, there is one concept which I found harder to understand at first: Hypermedia. Let it be that without this concept, you&amp;rsquo;re missing out on an extremely important strength of REST. Hypermedia enables you to build dumb - or smart, depending on your perspective - clients, which are mostly driven by the server. Practically, this is implemented as resources embedding links which allow the client to discover and navigate through your RESTful service.</description>
    </item>
    
    <item>
      <title>Slides and code from my Tunisia REST and ASP.NET Web API session</title>
      <link>https://jefclaes.be/2012/09/slides-and-code-from-my-tunisia-rest.html</link>
      <pubDate>Thu, 13 Sep 2012 08:55:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/09/slides-and-code-from-my-tunisia-rest.html</guid>
      <description>I just returned from a four day trip to Tunisia with Euricom. Next to indulging on the sun, food and all-inclusive cocktails, getting to know each other in a less professional setting, we spent somewhere around half of our days - and this is a rather generous estimate - doing technical sessions and workshops.
I gave a 90 minute long crash course on REST and ASP.NET Web API.
Content REST:</description>
    </item>
    
    <item>
      <title>Supporting the OPTIONS verb in ASP.NET Web API</title>
      <link>https://jefclaes.be/2012/09/supporting-options-verb-in-aspnet-web.html</link>
      <pubDate>Sun, 02 Sep 2012 18:27:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/09/supporting-options-verb-in-aspnet-web.html</guid>
      <description>ASP.NET Web API controllers support only four HTTP verbs by convention: GET, PUT, POST and DELETE. The full list of existing HTTP verbs is more extensive though. One of those unsupported verbs which can be particularly useful for API discovery and documentation is the OPTIONS verb.
 The OPTIONS method represents a request for information about the communication options available on the request/response chain identified by the Request-URI. This method allows the client to determine the options and/or requirements associated with a resource, or the capabilities of a server, without implying a resource action or initiating a resource retrieval.</description>
    </item>
    
    <item>
      <title>Is serialization really that expensive?</title>
      <link>https://jefclaes.be/2012/08/is-serialization-really-that-expensive.html</link>
      <pubDate>Wed, 22 Aug 2012 13:19:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/08/is-serialization-really-that-expensive.html</guid>
      <description>While wading through an exotic codebase, I stumbled upon a static class named Convert. This class contained somewhere around 2700 (non-generated) lines of code, where each method manually converted some object to a simple textual representation. These methods were then used to convert requests and reponses to and from a remote third party service before logging them to the database for auditing reasons.
public static class Convert { public static string PaymentRequest(PaymentRequest req) { var sb = new StringBuilder(); sb.</description>
    </item>
    
    <item>
      <title>My learning resources distilled</title>
      <link>https://jefclaes.be/2012/08/my-learning-resources-distilled.html</link>
      <pubDate>Sun, 19 Aug 2012 16:10:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/08/my-learning-resources-distilled.html</guid>
      <description>I have picked up a few new tools this summer (MongoDB, NancyFx and WebAPI), and it occurred to me that I&amp;rsquo;ve built certain habits these last few years in how I make use of all the learning resources out there.
I tried to identify all of them, to then categorize them, to finally order them according to in which phase of my study process I use them.
The written and spoken word The first thing I look for online is documentation.</description>
    </item>
    
    <item>
      <title>Finito</title>
      <link>https://jefclaes.be/2012/07/finito.html</link>
      <pubDate>Mon, 30 Jul 2012 22:23:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/07/finito.html</guid>
      <description>With this last post, our trip to Italy has come to an end. We have spent these last few days practicing several indispensable tourist activities: testing the ice cold lake water, to wriggle between other sunbathers on the packed beach right after, exuberant eating and drinking, reading novels, and sauntering between prullaria shops.
Fortuitously, one of our last evenings here was upgraded by fireworks over an already moonlit Lake Garda. This outlying location gave the fireworks show an extra notch.</description>
    </item>
    
    <item>
      <title>Milano</title>
      <link>https://jefclaes.be/2012/07/milano.html</link>
      <pubDate>Fri, 27 Jul 2012 22:25:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/07/milano.html</guid>
      <description>After Venice on Wednesday, we decided to stay in Torbole for a relaxing hike yesterday. As it turned out, the hiking trail that was described in the brochures as suitable for all and with a duration of 1h20, in reality took us 2h30 and sour calves to complete. The views of the lake&amp;rsquo;s valley and its school of windsurfers defying the wind were worth the sweat though. Arriving at the endpoint, and discovering that we had to wait over an hour for the bus to take us back, we stumbled upon one of the best hidden lake side terraces we&amp;rsquo;ve seen yet.</description>
    </item>
    
    <item>
      <title>The Floating City</title>
      <link>https://jefclaes.be/2012/07/the-floating-city.html</link>
      <pubDate>Thu, 26 Jul 2012 00:38:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/07/the-floating-city.html</guid>
      <description>Yesterday we cruised along the eastern coastline of Lake Garda. Plan A was to visit Malcesine and take the cableway up to the top of Monte Baldo, but since the line at the ticket center resembled one of a Justin Bieber concert, we skipped the cableway. Maybe we&amp;rsquo;ll give it another try later this week, but then earlier in the day. We continued our journey along the coast, passing past several genuinely picturesque villages.</description>
    </item>
    
    <item>
      <title>Ferrari red. Lamborghini yellow.</title>
      <link>https://jefclaes.be/2012/07/ferrari-red-lamborghini-yellow.html</link>
      <pubDate>Tue, 24 Jul 2012 00:56:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/07/ferrari-red-lamborghini-yellow.html</guid>
      <description>After 14 hours and 34 minutes in the car, driving 1148km, over the German autobahn, swerving Austrian roads, and the Italian autostrade, defying overwhelming hail storms, roadwork and miles long tunnel congestions, we arrived at Torbole, Italy.
Torbole is a small village, nestled between the mountains, right at the edge of Lake Garda. While the lakeside view is astonishing, you have to pick the right time to truly experience it. In the daytime, the village is overwhelmed by tourists; miles long rows of cars queue to enter the village, pizzerias and ristorantes on every corner, Germans galore.</description>
    </item>
    
    <item>
      <title>Should I unit- or integration test my ASP.NET Web API services?</title>
      <link>https://jefclaes.be/2012/07/should-i-unit-or-integration-test-my.html</link>
      <pubDate>Sun, 15 Jul 2012 22:37:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/07/should-i-unit-or-integration-test-my.html</guid>
      <description>Over the last two weeks, preparing for a talk, I have been doing some research on ASP.NET Web API. After working my way through the API, and the implementation of certain features, I looked at testing.
Similar to ASP.NET MVC, Web API allows you to create relatively small building blocks, which can replace parts of, or be added to an existing default global setup. This makes it possible for us to test each component in isolation: controllers, dependency resolvers, filters, serialization, type formatters, messagehandlers and routing.</description>
    </item>
    
    <item>
      <title>HtmlHelper to generate a top-level menu for areas</title>
      <link>https://jefclaes.be/2012/07/htmlhelper-to-generate-top-level-menu.html</link>
      <pubDate>Sun, 08 Jul 2012 19:10:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/07/htmlhelper-to-generate-top-level-menu.html</guid>
      <description>Last week, we had to set up a new ASP.NET MVC web application, using a somewhat customized Twitter Bootstrap build. Because the application has multiple functional contexts, we divided it in multiple parts using areas. Since these areas were a one-to-one mapping with the top-level menu items, we tried abstracting the creation of the menu items, ánd the management of setting the active item, into an HtmlHelper.
Let&amp;rsquo;s say, for this example, that we have six areas: Images, Maps, Play, Search, Video and Blog, and we want to render a list item for each one of them.</description>
    </item>
    
    <item>
      <title>On crime and document stores</title>
      <link>https://jefclaes.be/2012/07/on-crime-and-document-stores.html</link>
      <pubDate>Sun, 01 Jul 2012 16:04:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/07/on-crime-and-document-stores.html</guid>
      <description>Having worked with several storage paradigms over these last few months - from flatfiles, to NoSQL, to the big enterprisey relational databases -, I have spent plenty of time trying to make sense of all the options out there. It wasn&amp;rsquo;t until I watched one of the last episodes of The Wire season 3 that I had an epiphany regarding modeling data in document stores. Yes, I know, I tend to take those things home with me.</description>
    </item>
    
    <item>
      <title>Persisting model state when using PRG</title>
      <link>https://jefclaes.be/2012/06/persisting-model-state-when-using-prg.html</link>
      <pubDate>Sun, 17 Jun 2012 16:48:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/06/persisting-model-state-when-using-prg.html</guid>
      <description>I&amp;rsquo;ve been working on an ASP.NET MVC application in which we frequently apply the Post/Redirect/Get pattern. One of the direct consequences of applying this pattern is that you often want to persist the model state across redirects, so that you don&amp;rsquo;t lose validation errors, or the values of input fields.
To persist the model state across redirects, we can put TempData to work. The sole purpose of TempData is exactly this; persisting state until the next request.</description>
    </item>
    
    <item>
      <title>Making my first NancyFx test pass</title>
      <link>https://jefclaes.be/2012/06/making-my-first-nancyfx-test-pass.html</link>
      <pubDate>Mon, 11 Jun 2012 16:47:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/06/making-my-first-nancyfx-test-pass.html</guid>
      <description>Like I already said last week, I have been dabbling a bit with NancyFx lately.
This week I took a serious look at testing Nancy modules and Razor views. Due to Nancy&amp;rsquo;s defaults and conventions, it takes a little while to set up Nancy in a test context. Then again, Nancy&amp;rsquo;s granularity makes it simple enough to set up a solid test infrastructure by replacing some of its building blocks.</description>
    </item>
    
    <item>
      <title>Book review: The Art of Agile Development</title>
      <link>https://jefclaes.be/2012/06/book-review-art-of-agile-development.html</link>
      <pubDate>Sun, 10 Jun 2012 19:42:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/06/book-review-art-of-agile-development.html</guid>
      <description>While I have - obviously - read the Agile Manifesto before, and regularly click through to articles on agile, I had never read an extensive work on it. Browsing for a good book, I was advised by a peer to get The Art of Agile Development.
I wholeheartedly believe in the Agile Manifesto, but somewhere along the way Agile - with a capital A - got somewhat of a bad rep.</description>
    </item>
    
    <item>
      <title>The &#39;everyone should learn to code&#39; dilemma</title>
      <link>https://jefclaes.be/2012/06/everyone-should-learn-to-code-dilemma.html</link>
      <pubDate>Sun, 03 Jun 2012 16:40:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/06/everyone-should-learn-to-code-dilemma.html</guid>
      <description>Back when I was working on software for fire departments, we started thinking about reworking a critical piece of our solution: deployment plans. In a fire department domain, deployment plans help to make a suggestion to the dispatcher about which units should be dispatched to a location when an incident is called in. The suggested composition of units depends on a wide range of variables: availability, response time, ranks, type of incident, required tools, &amp;hellip; , even politics.</description>
    </item>
    
    <item>
      <title>The open plan fallacy testimonials</title>
      <link>https://jefclaes.be/2012/05/open-plan-fallacy-testimonials.html</link>
      <pubDate>Sun, 27 May 2012 15:36:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/05/open-plan-fallacy-testimonials.html</guid>
      <description>I wrote an article titled &amp;lsquo;The open plan fallacy&amp;rsquo; just two weeks ago. Earlier this week a similar article was published by the New York Times. The content of that article wasn&amp;rsquo;t particularly extraordinary, but the comments were. I waded through all of them on my daily commute, and it&amp;rsquo;s really hard to find one in favor of open plan offices - people seem to be enraged.
I handpicked some of the most interesting ones.</description>
    </item>
    
    <item>
      <title>Painless database logging with mongoDB</title>
      <link>https://jefclaes.be/2012/05/painless-database-logging-with-mongodb.html</link>
      <pubDate>Sun, 20 May 2012 17:18:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/05/painless-database-logging-with-mongodb.html</guid>
      <description>While browsing the source code of the ELMAH mongoDB provider, I learned about a special type of collections: capped collections.
From the mongoDB documentation:
 Capped collections are fixed sized collections that have a very high performance auto-FIFO age-out feature (age out is based on insertion order). In addition, capped collections automatically, with high performance, maintain insertion order for the documents in the collection; this is very powerful for certain use cases such as logging.</description>
    </item>
    
    <item>
      <title>The open plan fallacy</title>
      <link>https://jefclaes.be/2012/05/open-plan-fallacy.html</link>
      <pubDate>Sun, 13 May 2012 16:20:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/05/open-plan-fallacy.html</guid>
      <description>I haven&amp;rsquo;t worked in a whole lot of places, somewhere around four, but every single one of them used an open plan to structure their workplace. From what I hear from others, it&amp;rsquo;s the standard.
There are a few things to say about the advantages of an open office layout. They should stimulate communication, create more opportunities for observing and learning from others and be more cost-effective. I&amp;rsquo;m afraid it&amp;rsquo;s the latter which is the biggest driver though.</description>
    </item>
    
    <item>
      <title>Why I will always love RSS</title>
      <link>https://jefclaes.be/2012/05/why-i-will-always-love-rss.html</link>
      <pubDate>Sun, 06 May 2012 16:50:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/05/why-i-will-always-love-rss.html</guid>
      <description>There has been a lot of noise in the tech community earlier this year about how RSS is supposedly having one foot in the grave. If that would be even remotely true, I hope it dies with its boots on. The herald would be browsers and social networking sites killing or hiding support for RSS. While that may be true, their motives shouldn&amp;rsquo;t rig our opinions.
RSS has never worked out for the regular consumer, not directly anyways.</description>
    </item>
    
    <item>
      <title>My InfoQ article on HTML5 offline web applications</title>
      <link>https://jefclaes.be/2012/05/my-infoq-article-on-html5-offline-web.html</link>
      <pubDate>Wed, 02 May 2012 20:09:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/05/my-infoq-article-on-html5-offline-web.html</guid>
      <description>After writing a few things on HTML5 offline web applications earlier this year, I got contacted by InfoQ to write an in-detail article on the subject for them. I hesitated at first, because I was afraid that it would feel too much like work, taking the fun out of my writing. Turns out it wasn&amp;rsquo;t like that at all. The guys at infoQ were really relaxed to work with, asking interesting questions and giving useful feedback, without forcing me into a certain direction.</description>
    </item>
    
    <item>
      <title>Some Servicelocator pattern stinks</title>
      <link>https://jefclaes.be/2012/04/some-servicelocator-pattern-stinks.html</link>
      <pubDate>Tue, 17 Apr 2012 20:33:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/04/some-servicelocator-pattern-stinks.html</guid>
      <description>I have been working on a somewhat legacy codebase which makes use of the Servicelocator pattern. Although I always thought of Dependecy Injection to be the superior pattern, I was pleased to find some Inversion of Control implementation in there. Working with the codebase, I discovered first hand how easily, when used without caution and discipline, the Servicelocator pattern can introduce code rot.
I will walk you through some of the issues I have with the Servicelocator pattern, mostly looking at it from a test perspective.</description>
    </item>
    
    <item>
      <title>Visualizing the offline application cache update progress</title>
      <link>https://jefclaes.be/2012/04/visualizing-offline-application-cache.html</link>
      <pubDate>Wed, 11 Apr 2012 16:27:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/04/visualizing-offline-application-cache.html</guid>
      <description>I wrote about using the HTML5 application cache earlier, mostly focusing on generating and serving the manifest file using ASP.NET MVC. I also bitched about how not one browser I know of gives an indication of the application cache update progress.
Today I wanted to write something about how you can visualize the application cache update progress yourself.
The applicationCache API has several useful and rather straightforward events we can handle to inform the user of the update progress.</description>
    </item>
    
    <item>
      <title>Check for local file browsing with JavaScript</title>
      <link>https://jefclaes.be/2012/04/check-for-local-file-browsing-with.html</link>
      <pubDate>Mon, 02 Apr 2012 15:34:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/04/check-for-local-file-browsing-with.html</guid>
      <description>Because I do most of my research while commuting by train, I often pull entire websites offline using httrack. While browsing the [jQuery Mobile documentation](http://jquerymobile.com/demos/1.1.0-rc.1/ locally this morning, I stumbled upon following gem.

I was curious to see how they determine whether a page is browsed locally or not. Looking into the source, I was a bit dissapointed to find nothing but plain common sense. The trick is comparing the protocol of the current location with known local protocols.</description>
    </item>
    
    <item>
      <title>Add images to a GitHub readme</title>
      <link>https://jefclaes.be/2012/04/add-images-to-github-readme.html</link>
      <pubDate>Sun, 01 Apr 2012 19:32:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/04/add-images-to-github-readme.html</guid>
      <description>Today I wanted to add some screenshots to a GitHub readme for the sake of documenting. While this wasn&amp;rsquo;t particularly hard, I do had to iterate a few times before I got it right.
Hosting the images You could simply add the images to your repository and reference them using the raw url&amp;rsquo;s, but this isn&amp;rsquo;t very efficient. Using this method, every request needs to go through GitHub&amp;rsquo;s application layer. It&amp;rsquo;s far better to make use of GitHub Pages, a feature purely designed to publish web content.</description>
    </item>
    
    <item>
      <title>How a web application can download and store over 2GB without you even knowing it</title>
      <link>https://jefclaes.be/2012/03/how-web-application-can-download-and.html</link>
      <pubDate>Sun, 25 Mar 2012 13:11:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2012/03/how-web-application-can-download-and.html</guid>
      <description>I have been experimenting with the HTML5 offline application cache some more over the last few days, doing boundary tests in an attempt to learn more about browser behaviour in edge cases.
One of these experiments was testing the cache quota.
Two weeks ago, I blogged about generating and serving an offline application manifest using ASP.NET MVC.
I reused that code to add hundreds of 7MB PDF files to the cache.</description>
    </item>
    
    <item>
      <title>Sent from my phone</title>
      <link>https://jefclaes.be/2012/03/sent-from-my-phone.html</link>
      <pubDate>Sat, 17 Mar 2012 19:46:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/03/sent-from-my-phone.html</guid>
      <description>According to Matt from 37signals the line &amp;ldquo;Sent from my iPhone&amp;rdquo; at the bottom of an email means this:
 Let’s be honest. “Sent from my iPhone” really means “I’m not going to bother to proofread and correct this because it would take me an extra 30 seconds.”
 I agree. I too use this line as an excuse to write a terse message and omit proper salutations.
However, I also think these four simple words greatly helped the viral growth of the mobile phone.</description>
    </item>
    
    <item>
      <title>HTML5 Offline Web applications as an afterthought in ASP.NET MVC</title>
      <link>https://jefclaes.be/2012/03/html5-offline-web-applications-as.html</link>
      <pubDate>Wed, 14 Mar 2012 15:39:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/03/html5-offline-web-applications-as.html</guid>
      <description>Recently I prototyped a mobile web application using ASP.NET MVC, jQuery Mobile and some HTML5 features. One of the key goals was to find out how far you can push a web &amp;lsquo;application&amp;rsquo; until the browser starts getting in the way. Working disconnected is one of these things that appear to be a major showstopper at first.
However - to my surprise honestly - the HTML5 Offline Web applications API seems to be widely implemented across modern browsers already.</description>
    </item>
    
    <item>
      <title>Learning: the Hacker Way</title>
      <link>https://jefclaes.be/2012/03/learning-the-hacker-way/</link>
      <pubDate>Sun, 11 Mar 2012 11:08:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/03/learning-the-hacker-way/</guid>
      <description>I have had a fair amount of discussions on continuous learning and knowledge sharing the past few days. It became rather obvious that a lot of us have developed their own techniques, but also that maybe most of us are still in search of more efficient techniques. Having gone through several phases myself, I would like to share my current way of learning: the Hacker Way.
Here are some snippets taken from a recent letter from Mark Zuckerberg addressed to the Facebook shareholders.</description>
    </item>
    
    <item>
      <title>ASP.NET MVC4 bundling in ASP.NET MVC3</title>
      <link>https://jefclaes.be/2012/02/aspnet-mvc4-bundling-in-aspnet-mvc3.html</link>
      <pubDate>Sat, 25 Feb 2012 20:26:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/02/aspnet-mvc4-bundling-in-aspnet-mvc3.html</guid>
      <description>One of the new wildly evangelized features of ASP.NET MVC4 is the built-in support for bundling and minification of scripts and stylesheets.
I don&amp;rsquo;t see any reason why this new feature wouldn&amp;rsquo;t work for ASP.NET MVC3 though. If you open the packages config of an ASP.NET MVC4 beta project, you will find that bundling support lives in the Microsoft.Web.Optimization package.
&amp;lt;package id=&amp;#34;Microsoft.Web.Optimization&amp;#34; version=&amp;#34;1.0.0-beta&amp;#34; /&amp;gt; So we should just be able to install this package for an ASP.</description>
    </item>
    
    <item>
      <title>There&#39;s no place for monogamy in technology</title>
      <link>https://jefclaes.be/2012/02/theres-no-place-for-monogamy-in.html</link>
      <pubDate>Mon, 20 Feb 2012 08:43:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/02/theres-no-place-for-monogamy-in.html</guid>
      <description>In this post I would like to share some of my thoughts on a recent post by James Hague titled &amp;lsquo;Don&amp;rsquo;t Fall in Love With Your Technology&amp;rsquo;. If you haven&amp;rsquo;t read that post yet, please do, it&amp;rsquo;s so short that me summarizing it here would be silly.
I think there is nothing wrong with falling in love with your technology per se. If you want to have a fair relationship with your technology, you have to invest in her.</description>
    </item>
    
    <item>
      <title>Book review: Working with NHibernate 3.0</title>
      <link>https://jefclaes.be/2012/02/book-review-working-with-nhibernate-30.html</link>
      <pubDate>Wed, 08 Feb 2012 20:21:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/02/book-review-working-with-nhibernate-30.html</guid>
      <description>It&amp;rsquo;s been a while since I wrote my last book review, mostly because I&amp;rsquo;m still trying to figure out when it adds value to write one. For this one it was pretty obvious, there are far too little reviews out there.
Being new to NHibernate, and NHibernate being known as having a steep learning curve, I thought it would be a good idea to do some reading. Searching for books on NHibernate 3.</description>
    </item>
    
    <item>
      <title>Testing DI bootstrappers</title>
      <link>https://jefclaes.be/2012/02/testing-di-bootstrappers.html</link>
      <pubDate>Mon, 06 Feb 2012 08:59:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/02/testing-di-bootstrappers.html</guid>
      <description>While your Dependency Injection bootstrappers - being responsible for gluing your application together - are a vital part of your application, they are seldom put under test. I don&amp;rsquo;t see any reason why they shouldn&amp;rsquo;t be though. The cost of these tests is negligible, definitely if you compare it to the cost of the often catastrophical outcome of bugs in your bootstrappers.
I encourage you to take a look at the commit history of your DI bootstrappers; I bet they change a lot.</description>
    </item>
    
    <item>
      <title>A solar storm anecdote</title>
      <link>https://jefclaes.be/2012/02/a-solar-storm-anecdote/</link>
      <pubDate>Wed, 01 Feb 2012 08:43:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/02/a-solar-storm-anecdote/</guid>
      <description>Last week, several news channels reported on the strongest solar storm since 2005. This news item reminded me of a peculiar support ticket we received one gray Monday morning a few years ago, when I was still writing software for fire departments.
# Ticket 7238 Subject: **AVL broken** Status: New Description 06:22 Vehicles stay mostly stationary on the map, even when we are positive they are en route. Fire departments that have to cover a large area - and are wealthy enough - often use AVL (Automatic Vehicle Location) to track their vehicles and visualize them on a map.</description>
    </item>
    
    <item>
      <title>How Wikipedia uses HTML5 to save bandwidth</title>
      <link>https://jefclaes.be/2012/01/how-wikipedia-uses-html5-to-save.html</link>
      <pubDate>Thu, 19 Jan 2012 20:56:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/01/how-wikipedia-uses-html5-to-save.html</guid>
      <description>Something I hadn&amp;rsquo;t noticed until recently is that Wikipedia tries to use the browser&amp;rsquo;s native SVG support to render certain images. For example, if you search for a high resolution image of your country&amp;rsquo;s flag, you will probably end up viewing an SVG. Wikipedia also offers downloads to the image rendered as a PNG though.
Next to being able to scale to an arbitrary size without suffering data loss, the SVG data format allows images to be far more compact.</description>
    </item>
    
    <item>
      <title>Autocorrecting unknown actions using the Levenshtein distance</title>
      <link>https://jefclaes.be/2012/01/autocorrecting-unknown-actions-using.html</link>
      <pubDate>Sun, 15 Jan 2012 16:04:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2012/01/autocorrecting-unknown-actions-using.html</guid>
      <description>This weekend I prototyped an idea I had earlier this week: autocorrecting unknown actions in ASP.NET MVC.
Handling unknown actions To give you an example, let&amp;rsquo;s say I have a Home controller with an action named Kitten on it. If there is an incoming route for the Home controller with Kitty (instead of Kitten) as the action name, the controller will not be able to invoke any action method and instead will call the HandleUnknownAction method.</description>
    </item>
    
    <item>
      <title>2011 Annual Review</title>
      <link>https://jefclaes.be/2011/12/2011-annual-review.html</link>
      <pubDate>Mon, 26 Dec 2011 21:35:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/12/2011-annual-review.html</guid>
      <description>Since the end of the year is approaching, I would like to look back on 2011 and take a peek at 2012. Unlike the years before, I&amp;rsquo;m hardly setting any goals this year. Interests change so quickly, and new opportunities present themselves so regularly, I feel like it might be ignorant to set these things in stone.
My career The year started out interesting, working on a brand new product for fire departments at Ferranti Computer Systems.</description>
    </item>
    
    <item>
      <title>2011&#39;s most read posts</title>
      <link>https://jefclaes.be/2011/12/2011s-most-read-posts.html</link>
      <pubDate>Sat, 17 Dec 2011 19:33:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/12/2011s-most-read-posts.html</guid>
      <description>I compiled a list of most popular posts that were published on this blog in 2011. Unlike last year, and the year before that, this year it&amp;rsquo;s not a strict top five list. While analyzing the statistics, I found out that a few topics -covered over multiple posts - were popular this year.
Preparing for my HTML5 Webcamps session on WebSockets, I wrote a few posts on the Microsoft WebSockets prototype.</description>
    </item>
    
    <item>
      <title>When should you take performance into consideration?</title>
      <link>https://jefclaes.be/2011/11/when-should-you-take-performance-into.html</link>
      <pubDate>Sun, 27 Nov 2011 17:55:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/11/when-should-you-take-performance-into.html</guid>
      <description>Before publishing my previous post on rewriting an if, I knew some people would hate it, because the refactored construct is less performant.
Although I think performance is important, relevant performance improvements are, apart from in tight loops, hardly ever to find in language constructs. To put it more bluntly, they are a waste of time. When translating your thoughts into code, you should aim to make your intentions as clear as possible for the person who comes after you.</description>
    </item>
    
    <item>
      <title>Rewriting an if</title>
      <link>https://jefclaes.be/2011/11/rewriting-if.html</link>
      <pubDate>Thu, 24 Nov 2011 21:12:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/11/rewriting-if.html</guid>
      <description>Yesterday I came across an if statement that looked something like this.
if (arg == &amp;#34;a&amp;#34; || arg == &amp;#34;b&amp;#34; || arg == &amp;#34;c&amp;#34; || arg == &amp;#34;d&amp;#34; || arg == &amp;#34;e&amp;#34;) { Console.WriteLine(true); } An alternative way of writing this could look like this.
if (new [] { &amp;#34;a&amp;#34;, &amp;#34;b&amp;#34;, &amp;#34;c&amp;#34;, &amp;#34;d&amp;#34;, &amp;#34;e&amp;#34; }.Contains(arg)) Console.WriteLine(true); I can&amp;rsquo;t remember in which Github repository I spotted this technique, but I&amp;rsquo;m sure it was written in something other than C#.</description>
    </item>
    
    <item>
      <title>Blame no one but yourself</title>
      <link>https://jefclaes.be/2011/11/blame-no-one-but-yourself.html</link>
      <pubDate>Wed, 23 Nov 2011 21:24:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/11/blame-no-one-but-yourself.html</guid>
      <description>Blame no one but yourself. This is one of the few quotes I remember months after reading this book. Although it&amp;rsquo;s a harsh statement, there definitely is some truth to it.
Once I started observing my own behavior when faced with failure, I caught myself regularly blaming others for failures to which I am - at least - an accomplice.
Think about it. You might be guilty of this too.</description>
    </item>
    
    <item>
      <title>Daydreaming about jQuery Mobile and the WebAPI</title>
      <link>https://jefclaes.be/2011/11/blame-no-one-but-yourself.html</link>
      <pubDate>Sun, 20 Nov 2011 17:24:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/11/blame-no-one-but-yourself.html</guid>
      <description>I recently blogged about programming for the future of mobile with jQuery Mobile and the WebAPI. You probably heard that jQuery Mobile 1.0 was released earlier this week. Although it will take a while before we will see some actual results from the WebAPI initiative, that shouldn&amp;rsquo;t keep us from letting our minds play with things that might be possible one day using the WebAPI.
The thoughts in this post were provoked by an interesting comment Kristof Claes left on my previous post.</description>
    </item>
    
    <item>
      <title>Programming for the future of mobile</title>
      <link>https://jefclaes.be/2011/11/programming-for-future-of-mobile.html</link>
      <pubDate>Wed, 09 Nov 2011 22:27:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/11/programming-for-future-of-mobile.html</guid>
      <description>I have been working on something small on the side lately. I hardly have anything to show for it though, most of it is still being shaped in my head.
Anyhow, a very important part of the front-end is built using jQuery mobile. Although the framework hasn&amp;rsquo;t been released - release candidates are available though -, it&amp;rsquo;s something you should start looking into today. Why? Because the browser is the future of mobile applications.</description>
    </item>
    
    <item>
      <title>The gift of legacy</title>
      <link>https://jefclaes.be/2011/10/gift-of-legacy.html</link>
      <pubDate>Sun, 30 Oct 2011 13:36:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/10/gift-of-legacy.html</guid>
      <description>Just after graduating, I hated legacy with the heat of a thousand suns. I felt unfortunate, having to work on old code, built using outdated technologies, while software is all about making new and shiny things. Right, guys? Those naïve expectations of a rookie got crumbled very soon. Legacy is a constant in our industry. You can try to ignore it as long as possible, but it&amp;rsquo;s impossible to keep that up forever.</description>
    </item>
    
    <item>
      <title>Book review: The Art of Unit Testing</title>
      <link>https://jefclaes.be/2011/10/book-review-art-of-unit-testing.html</link>
      <pubDate>Thu, 06 Oct 2011 21:08:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/10/book-review-art-of-unit-testing.html</guid>
      <description>I think The Art of Unit Testing targets a broad audience. Beginners will find every part of the book useful, where intermediates might be more interested in the final two parts.
Roy Osherove starts this book by laying a solid foundation of the unit testing concept. Why is testing important? What defines a good unit test, and how does a unit test differ from an integration test? In the second part of the book, he demonstrates the use of two core unit testing techniques: stubs and mocks.</description>
    </item>
    
    <item>
      <title>A real developer knows when to pull the plug</title>
      <link>https://jefclaes.be/2011/09/a-real-developer-knows-when-to-pull-the-plug/</link>
      <pubDate>Thu, 29 Sep 2011 20:38:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/a-real-developer-knows-when-to-pull-the-plug/</guid>
      <description>My mini-website arealdeveloper.com will no longer be available online after tomorrow.
I slapped it together over a weekend, trying out WebMatrix, which turned out to be the perfect companion for building small things.
A pleasant surprise was the mention of &amp;lsquo;A Real Developer&amp;rsquo; by the guys at Channel9. This made the traffic go through the roof for a few days.
A few months later the site was a ghosttown. But I don&amp;rsquo;t mind, had to happen.</description>
    </item>
    
    <item>
      <title>Comfortably numb</title>
      <link>https://jefclaes.be/2011/09/comfortably-numb.html</link>
      <pubDate>Wed, 21 Sep 2011 20:51:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/comfortably-numb.html</guid>
      <description>Something that can bother me tremendously is being surrounded by people who are in a constant state of being comfortably numb. People who don&amp;rsquo;t welcome change, try to scare away new concepts and are just too much at home in their comfort zone. Some are perfectly happy filling their days keeping up appearances of being busy. They don&amp;rsquo;t care about self-improvement, but only care about augmenting their paychecks by accumulating as much legacy baggage as possible, with the sole intention of being perceived as an irreplaceable asset to the company, whilst not having to leave their comfort zone.</description>
    </item>
    
    <item>
      <title>Building small things</title>
      <link>https://jefclaes.be/2011/09/building-small-things.html</link>
      <pubDate>Sun, 18 Sep 2011 16:35:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/building-small-things.html</guid>
      <description>Due to the nature of things we build in our day to day job, writing software can wear out even the most fit of us.
Most software jobs make you constantly deal with complexity. The amount of things which can lead to a complex software project are immense. A poor first design, and failure to redesign. External dependencies, which seem to behave different every time around. Or just the complexity of the problems itself.</description>
    </item>
    
    <item>
      <title>Once upon a time in the West</title>
      <link>https://jefclaes.be/2011/09/once-upon-time-in-west.html</link>
      <pubDate>Sat, 17 Sep 2011 11:15:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/once-upon-time-in-west.html</guid>
      <description>The girlfriend and I returned from our West Coast roadtrip yesterday morning.
We found this trip to be an unforgettable experience, which made us even more hungry for future travels.
This blog will return to business as usual, with mainly technical content and opinions.
Here is an overview of our posts exploring the West Coast:
 If you&amp;rsquo;re going to San Francisco Yosemite skyscrapers Sands of Nevada Rusty Rocks From Glen to Grand Edge of eternity Fear and loathing in Las Vegas City of fallen angels</description>
    </item>
    
    <item>
      <title>City of fallen angels</title>
      <link>https://jefclaes.be/2011/09/city-of-fallen-angels.html</link>
      <pubDate>Tue, 13 Sep 2011 05:45:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/city-of-fallen-angels.html</guid>
      <description>After seeing the celebrities at Madame Tussaud&amp;rsquo;s in Las Vegas, we went for the real deal.
Turns out Hollywood is a lot less glamourous than we expected. The Walk of Fame isn&amp;rsquo;t a lot different from any other gray sidewalk, paved with long-forgotten stars. The famous Hollywood sign isn&amp;rsquo;t even lit a night, making the contrast with Beverly Hills at the other side of town even bigger. Maybe there&amp;rsquo;s another side to Hollywood that we haven&amp;rsquo;t seen, since we only stayed for two days, one of which at the Universal Studios.</description>
    </item>
    
    <item>
      <title>Fear and loathing in Las Vegas</title>
      <link>https://jefclaes.be/2011/09/fear-and-loathing-in-las-vegas.html</link>
      <pubDate>Sun, 11 Sep 2011 02:49:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/fear-and-loathing-in-las-vegas.html</guid>
      <description>Driving back into the desert after our breakfast, with Las Vegas in the rear-view mirror, we secretly feel a little relieved to be heading back to the real world. The cocktail of fake pyramids, indoor jungles, Paris landmarks, castles and volcanoes became a little nauseating. With hotels and casinoes resembling labyrinths, designed to get people trapped inside, it feels liberating to drive through the wide open landscape again.
Some of the things we enjoyed the most were the late nights walking the Strip, watching free shows, standing on top of the Stratosphere and posing with the wax celebs at Madame Tussaud&amp;rsquo;s.</description>
    </item>
    
    <item>
      <title>Edge of eternity</title>
      <link>https://jefclaes.be/2011/09/edge-of-eternity.html</link>
      <pubDate>Wed, 07 Sep 2011 06:40:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/edge-of-eternity.html</guid>
      <description>We all know the Grand Canyon as one of the seven natural wonders of the world, today I learned why. As one of the locals described: &amp;lsquo;Pretty amazing for a big hole in the ground&amp;rsquo;. Being the closest to the south entrance, we visited the South Rim of the canyon. A trip to the visitor center taught us there were no easy hikes (except for the going down part), so we didn&amp;rsquo;t attempt at one.</description>
    </item>
    
    <item>
      <title>From Glen to Grand</title>
      <link>https://jefclaes.be/2011/09/from-glen-to-grand.html</link>
      <pubDate>Tue, 06 Sep 2011 07:14:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/from-glen-to-grand.html</guid>
      <description>Yesterday, we drove from Saint-George to Page, Arizona. The Pipe Springs National Monument happened to be on our way, so we made a stop. Turned out there wasn&amp;rsquo;t much to see. A 30-minute ranger-led tour made it worthwhile though. During the tour through the Winsor Castle, she told us about the Mormons who used to live there. The Fort manager, also head of their Mormon church, married 58 women, resulting in plenty of children to work the Fort.</description>
    </item>
    
    <item>
      <title>Rusty rocks</title>
      <link>https://jefclaes.be/2011/09/rusty-rocks.html</link>
      <pubDate>Sun, 04 Sep 2011 07:23:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/rusty-rocks.html</guid>
      <description>We started the day with a short drive to Zion National Park. On our way we came across some colossal rock formations, layered with different shades of red. Since the park is almost entirely car free, we took the shuttle bus along the scenic route. We got off at different stops, to take short hikes to the park&amp;rsquo;s natural treasures. The Emerald Pools were first up, followed by the Weeping Rock and a riverside walk to the Narrows, which are architected by the Virgin river.</description>
    </item>
    
    <item>
      <title>Sands of Nevada</title>
      <link>https://jefclaes.be/2011/09/yesterday-evening-we-spent-night-in.html</link>
      <pubDate>Sat, 03 Sep 2011 06:29:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/yesterday-evening-we-spent-night-in.html</guid>
      <description>Yesterday evening we spent the night in a town called Tonopah, which is literally in the middle of nowhere. Today we continued our trip to Zion (Utah), driving hundreds of miles through the Nevada desert, getting sunburned on the way. There was not a soul in sight, except for cattle crossing the road, who seemed to be waiting for us to pass to say hello. We just arrived at St. George, which is a launching point to Zion National Park.</description>
    </item>
    
    <item>
      <title>Yosemite skyscrapers</title>
      <link>https://jefclaes.be/2011/09/yosemite-skyscrapers.html</link>
      <pubDate>Fri, 02 Sep 2011 07:10:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/09/yosemite-skyscrapers.html</guid>
      <description>These skyscrapers are, other than the enormous mountains, the redwood sequoia on top of them. Some of these trees are the same height as a thirty story building, which is higher than the Statue Of Liberty. It&amp;rsquo;s almost impossible to capture these giants on camera. 
After a short hike between the sequoia, we drove off to Yosemite Valley to discover the Yosemity Falls. Although the falls must be more impressive in Winter, they were still worth visiting.</description>
    </item>
    
    <item>
      <title>If you&#39;re going to San Francisco</title>
      <link>https://jefclaes.be/2011/08/if-youre-going-to-san-francisco.html</link>
      <pubDate>Wed, 31 Aug 2011 09:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/08/if-youre-going-to-san-francisco.html</guid>
      <description>While I&amp;rsquo;m writing this, the girlfriend and I are on our way from San Francisco to Yosemite National Park. We have spent two full days visiting &amp;lsquo;Fog City&amp;rsquo;. During these two intensive days we were able to see everything we aimed for, maybe more.
Financial District This part of town is definitely worth a visit. The multiplicity of skyscrapers merging into the San Francisco fog, is an impressive view. When the fog has gone, the shadows the buildings cast on each other are just as amazing.</description>
    </item>
    
    <item>
      <title>High Hopes</title>
      <link>https://jefclaes.be/2011/08/high-hopes.html</link>
      <pubDate>Mon, 08 Aug 2011 20:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/08/high-hopes.html</guid>
      <description>Last week, I resigned from my job at Ferranti Computer Systems. Three years ago, days after receiving my Graduate Diploma in Applied Computer Science, I had my first real-world working experience at Ferranti Computer Systems.
The first project I was assigned to, was a project for the Antwerp fire department. Along with two other graduates and four seniors, I was thrown in at the deep end. I always had solid grades in school, and was fairly confident that I grasped the material I was taught.</description>
    </item>
    
    <item>
      <title>Merge sorting in JavaScript</title>
      <link>https://jefclaes.be/2011/07/merge-sorting-in-javascript_1458.html</link>
      <pubDate>Tue, 26 Jul 2011 19:00:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/07/merge-sorting-in-javascript_1458.html</guid>
      <description>The latest addition to my [data structures and algorithms in JavaScript](https://github.com/JefClaes Data-structures-and-algorithms-in-JavaScript) is the merge sort algorithm.
There are four main steps in the merge sort algorithm (from Wikipedia):
 If the list is of length 0 or 1, then it is already sorted.  Otherwise:
 Divide the unsorted list into two sublists of about half the size. Sort each sublist recursively by re-applying the merge sort. Merge the two sublists back into one sorted list.</description>
    </item>
    
    <item>
      <title>My js data structures and algorithms now on GitHub</title>
      <link>https://jefclaes.be/2011/07/my-js-data-structures-and-algorithms.html</link>
      <pubDate>Sat, 23 Jul 2011 15:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/07/my-js-data-structures-and-algorithms.html</guid>
      <description>If you have been reading my blog lately, you know that I&amp;rsquo;m implementing some data structures and algorithms in JavaScript. So far, I have blogged about simple sorting algorithms, the stack data structure and the queue data structure. This week I have also implemented a doubly linked list. I started writing a post about that last implementation, but I didn&amp;rsquo;t like where it was going, so instead of writing about it, I have pushed everything to a public Git repository.</description>
    </item>
    
    <item>
      <title>Overoptimizing my JavaScript stack implementation for fun</title>
      <link>https://jefclaes.be/2011/07/overoptimizing-my-javascript-stack.html</link>
      <pubDate>Mon, 18 Jul 2011 21:00:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/07/overoptimizing-my-javascript-stack.html</guid>
      <description>Davy Brion made a comment on my JavaScript stack/queue implementation on Twitter last night: Any reason why you don&amp;rsquo;t immediately set elements to [] at declaration in your stack/queue example?
var elements; this.push = function(element) { if (typeof(elements) === &amp;#39;undefined&amp;#39;) { elements = []; } elements.push(element); } Yes, I made an overoptimization, and a bad one. In this implementation, you save a few bytes in memory if you initialize the stack, but don&amp;rsquo;t push elements.</description>
    </item>
    
    <item>
      <title>Stacks and queues in JavaScript</title>
      <link>https://jefclaes.be/2011/07/stacks-and-queues-in-javascript.html</link>
      <pubDate>Tue, 12 Jul 2011 21:00:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/07/stacks-and-queues-in-javascript.html</guid>
      <description>The second assignment in my &amp;lsquo;implementing data structures and algorithms in JavaScript&amp;rsquo; quest consists of two popular data structures: the stack and the queue.
The stack  A stack is a last in, first out (LIFO) abstract data type and data structure. A stack can have any abstract data type as an element, but is characterized by only three fundamental operations: push, pop and stack top.
 Implementing this turned out to be pretty easy.</description>
    </item>
    
    <item>
      <title>Simple sorting in JavaScript</title>
      <link>https://jefclaes.be/2011/07/simple-sorting-in-javascript.html</link>
      <pubDate>Thu, 07 Jul 2011 21:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/07/simple-sorting-in-javascript.html</guid>
      <description>About three years ago I graduated and got my degree in Applied Computer Science. Although it says Computer Science, we hardly ever focused on data structures and algorithms. Obviously, I now see that as a shortcoming. So I plan to make up for that by reading up on some of the basics. While at it, I might be blogging on some of the topics.
I am going to start by implementing some of the simple sorting algorithms in JavaScript.</description>
    </item>
    
    <item>
      <title>Should we get this tool?</title>
      <link>https://jefclaes.be/2011/06/should-we-get-this-tool.html</link>
      <pubDate>Wed, 15 Jun 2011 21:45:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/06/should-we-get-this-tool.html</guid>
      <description>This is a decision that often needs to be made by middle management. For managers the most natural way to make this call is by evaluating the return on investment. To calculate the ROI, you need to compare the gain of an investment relative to the amount of investment. And this is exactly where things get hard, if not impossible. Measuring developer productivity is one of the unsolvable problems in our industry.</description>
    </item>
    
    <item>
      <title>Book review: More Joel on Software</title>
      <link>https://jefclaes.be/2011/06/book-review-more-joel-on-software.html</link>
      <pubDate>Tue, 07 Jun 2011 19:00:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/06/book-review-more-joel-on-software.html</guid>
      <description>I was lucky to pick up a copy of More Joel on Software for only 5 euros at a bookfest last week. Turns out the book ships pretty cheap on Amazon as well.
More Joel on Software was written by Joel Spolsky, already a legend for launching The Stack Exchange Network with Jeff Atwood. Although it&amp;rsquo;s hard to not know him, I admittedly hadn&amp;rsquo;t read a lot of his material so far.</description>
    </item>
    
    <item>
      <title>Checking for anonymous types</title>
      <link>https://jefclaes.be/2011/05/checking-for-anonymous-types.html</link>
      <pubDate>Sat, 21 May 2011 18:00:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/05/checking-for-anonymous-types.html</guid>
      <description>Because I blogged about anonymous types last month, I thought following method would also make an interesting post.
private static bool IsAnonymousType(Type type) { Debug.Assert(type != null, &amp;#34;Type should not be null&amp;#34;); // HACK: The only way to detect anonymous types right now.  return Attribute.IsDefined(type, typeof(CompilerGeneratedAttribute), false) &amp;amp;&amp;amp; type.IsGenericType &amp;amp;&amp;amp; type.Name.Contains(&amp;#34;AnonymousType&amp;#34;) &amp;amp;&amp;amp; (type.Name.StartsWith(&amp;#34;&amp;lt;&amp;gt;&amp;#34;, StringComparison.OrdinalIgnoreCase) || type.Name.StartsWith(&amp;#34;VB$&amp;#34;, StringComparison.OrdinalIgnoreCase)) &amp;amp;&amp;amp; (type.Attributes &amp;amp; TypeAttributes.NotPublic) == TypeAttributes.NotPublic; } For a type to be anonymous:</description>
    </item>
    
    <item>
      <title>My thoughts on WebMatrix</title>
      <link>https://jefclaes.be/2011/05/my-thoughts-on-webmatrix/</link>
      <pubDate>Mon, 09 May 2011 21:15:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/05/my-thoughts-on-webmatrix/</guid>
      <description>After building arealdeveloper.com, I felt like I had to do a follow-up post sharing my experiences with WebMatrix. While doing some research, I came across this post by Rob Connery. And frankly, I think it&amp;rsquo;s almost impossible for me to add something to his findings.
In a nutshell For those who are here for the &amp;ldquo;tl;dr&amp;rdquo;, here are my thoughts on WebMatrix..
WebMatrix is the perfect framework to start with ASP.</description>
    </item>
    
    <item>
      <title>arealdeveloper.com mentioned on Channel9</title>
      <link>https://jefclaes.be/2011/05/arealdevelopercom-mentioned-on-channel9.html</link>
      <pubDate>Mon, 02 May 2011 21:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/05/arealdevelopercom-mentioned-on-channel9.html</guid>
      <description>While nosing around in the arealdeveloper.com analytics, I saw a bunch of traffic coming from Channel9. Clicking through, I found out A Real Developer was mentioned in this video (02:01). That&amp;rsquo;s a Channel9 front-page video!
That&amp;rsquo;s so awesome, I think it&amp;rsquo;s great people find it a fun project.
I have been listening to your feedback, and this Sunday I implemented some of your requests:
 Easier linking Sharing A feed Voting Comments  I try to keep everything as simple as possible, that&amp;rsquo;s why I implemented most of these features using two popular free plug-ins: AddThis and Disqus.</description>
    </item>
    
    <item>
      <title>arealdeveloper.com</title>
      <link>https://jefclaes.be/2011/04/arealdevelopercom.html</link>
      <pubDate>Tue, 26 Apr 2011 20:00:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/04/arealdevelopercom.html</guid>
      <description>A Real Developer is a side-project I built over the weekend poking around with WebMatrix.

It got a little out of hand. After publishing, I showed it to a few popular tweeps, and they were kind enough to mention it. 24 hours after the launch it has gotten over 3.5k unique visitors, 39k page views (see what I did there?) and over 240 submissions. Being mentioned by Scott Hanselman and Rey Bango helps.</description>
    </item>
    
    <item>
      <title>Prague impressions</title>
      <link>https://jefclaes.be/2011/04/prague-impressions.html</link>
      <pubDate>Sun, 24 Apr 2011 15:45:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/04/prague-impressions.html</guid>
      <description>Last year my girlfriend and I already made a trip to the Czech Republic, but we felt like we had spent to little time visiting Prague. We made up for that by making a follow-up trip last week.
Find some of our most memorable impressions captured on picture below..

The Lennon Wall

Love padlocks near the Lennon Wall.

Hiking route in the New Town district.

The Charles bridge from a distance.</description>
    </item>
    
    <item>
      <title>Anonymous type equality follow-up: Equals()</title>
      <link>https://jefclaes.be/2011/04/anonymous-type-equality-follow-up.html</link>
      <pubDate>Sun, 24 Apr 2011 12:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/04/anonymous-type-equality-follow-up.html</guid>
      <description>After publishing yesterday&amp;rsquo;s post on anonymous type equality, I received an interesting comment. The comment stated that even if the sequence of the property assignment were the same, the equality comparison would still return false, because the types generated by the C# compiler are reference types, making their references being tested for equality and not their data.
This is very true, unless the Equals() method is overridden. And this is exactly what the compiler does for us when we define anonymous types.</description>
    </item>
    
    <item>
      <title>Anonymous type equality</title>
      <link>https://jefclaes.be/2011/04/anonymous-type-equality/</link>
      <pubDate>Sat, 23 Apr 2011 15:15:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/04/anonymous-type-equality/</guid>
      <description>Let&amp;rsquo;s say you instantiate two variables (a and b) using anonymous types. They both have the same two properties (x and y) with equal values.
var a = new { x = 1, y = 2 }; var b = new { y = 2, x = 1 }; Do you think they are equal?
Console.WriteLine(a.Equals(b)); //Prints false :O They are not. Not something I expected!
If we look at the IL the C# compiler produced, it starts making sense though.</description>
    </item>
    
    <item>
      <title>Using C# keywords as variables</title>
      <link>https://jefclaes.be/2011/04/using-c-keywords-as-variables.html</link>
      <pubDate>Mon, 11 Apr 2011 19:00:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/04/using-c-keywords-as-variables.html</guid>
      <description>Hold it, don&amp;rsquo;t shoot me. I know this would be an awful practice, but it is an interesting C# compiler quirk nonetheless.
 Keywords are predefined reserved identifiers that have special meanings to the compiler. They cannot be used as identifiers in your program unless they include @ as a prefix. For example, @if is a legal identifier but if is not because it is a keyword.
 static void Main(string[] args) { var @if = &amp;#34;oh my.</description>
    </item>
    
    <item>
      <title>It&#39;s not how good you are, it&#39;s how good you want to be</title>
      <link>https://jefclaes.be/2011/04/its-not-how-good-you-are-its-how-good.html</link>
      <pubDate>Sun, 10 Apr 2011 20:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/04/its-not-how-good-you-are-its-how-good.html</guid>
      <description>This Christmas, my girlfriend and I got this little book called It&amp;rsquo;s not how good you are, it&amp;rsquo;s how good you want to be.
This book is mainly directed to (advertisement) designers, but since I feel that designers and developers do have a few things in common, we both like to create things, I also read it.
The content of this book is a collection of Paul Ardens observations on business and life presented in a very consumable format.</description>
    </item>
    
    <item>
      <title>Video, slides and source from my WebSockets talk</title>
      <link>https://jefclaes.be/2011/04/video-slides-and-source-from-my-websockets-talk/</link>
      <pubDate>Thu, 07 Apr 2011 21:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2011/04/video-slides-and-source-from-my-websockets-talk/</guid>
      <description>Yesterday, I gave a talk on WebSockets at HTML5 WebCamps Belgium.
 WebSockets on Fire
While the WebSockets API specification is not stable yet, various browser vendors have already implemented a prototype in their latest browser versions. Microsoft released their WebSockets prototype in December 2010. While there is no native implementation of WebSockets in IE9 just yet, for now they are providing a solution which works cross-browser, relying on a Silverlight client.</description>
    </item>
    
    <item>
      <title>Keeping WebSockets alive</title>
      <link>https://jefclaes.be/2011/03/keeping-websockets-alive.html</link>
      <pubDate>Sat, 12 Mar 2011 17:40:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/03/keeping-websockets-alive.html</guid>
      <description>The problem with using stateful connections on an imperfect place as the internet is that connections might drop. The server or an intermediary can drop the connection due to an idle timeout. Even a temporary problem at the server or a local network hiccup might kill your connection.
If you aren&amp;rsquo;t prepared to handle these scenarios, you will not be able to fully rely on WebSockets.
A simple solution The simplest solution is checking every few seconds whether the WebSocket is still opened.</description>
    </item>
    
    <item>
      <title>Why I still buy real books</title>
      <link>https://jefclaes.be/2011/02/why-i-still-buy-real-books.html</link>
      <pubDate>Tue, 01 Feb 2011 08:30:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/02/why-i-still-buy-real-books.html</guid>
      <description>As a technology geek, it should be hard to keep ignoring the latest generation of eReaders (read: the Kindle). With over three million devices sold, the Kindle has proven that it adds value to people&amp;rsquo;s lives, and that it&amp;rsquo;s a lot more than just a gadget.
Some of the most obvious benefits&amp;hellip; You can carry a whole library in your backpack. The price of an eBook often is substantially less than the hardcover version.</description>
    </item>
    
    <item>
      <title>Book review: The Art of Non-Conformity</title>
      <link>https://jefclaes.be/2011/01/book-review-art-of-non-conformity.html</link>
      <pubDate>Sat, 22 Jan 2011 14:00:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/01/book-review-art-of-non-conformity.html</guid>
      <description>The book The Art of Non-Conformity: Set Your Own Rules, Live the Life You Want, and Change the World was written by Chris Guillebeau.
I learned about this book through Chris&amp;rsquo; blog. He hosts a very popular blog where he writes on lifehacking, entrepreneurship and his goal to travel to each country in the world.
In this book Chris tries to show the reader that you don&amp;rsquo;t have the live your life the way other people expect you to.</description>
    </item>
    
    <item>
      <title>Book review: Got Fight?</title>
      <link>https://jefclaes.be/2011/01/book-review-got-fight.html</link>
      <pubDate>Sat, 15 Jan 2011 18:00:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/01/book-review-got-fight.html</guid>
      <description>I rarely review books with non-technical content here, but I just felt like I had to with this one.
The book Got Fight? was written by Forrest Griffin, assisted by Erich Krauss.
Forrest Griffin is one of the toughest light-heavyweight mixed martial artists competing in the UFC. If you are unfamiliar with MMA and UFC, I encourage you to watch one of the Forrest Griffin tribute videos on Youtube.</description>
    </item>
    
    <item>
      <title>Book review: Pro HTML5 Programming</title>
      <link>https://jefclaes.be/2011/01/book-review-pro-html5-programming.html</link>
      <pubDate>Thu, 06 Jan 2011 14:30:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2011/01/book-review-pro-html5-programming.html</guid>
      <description>The Apress book Pro HTML5 Programming was written by three authors: Peter Lubbers, Brian Albers and Frank Salim. In this book the authors introduce the reader to the most popular and useful features of HTML5.
The book contains 11 concise chapters: An overview of HTML5, the Canvas API, audio and video, the Geolocation API, the Communication API, the WebSocket API, Forms, the Web Workers API, the Web Storage API, Offline Web Applications and the future of HTML5.</description>
    </item>
    
    <item>
      <title>Reviewing and renewing resolutions</title>
      <link>https://jefclaes.be/2010/12/reviewing-and-renewing-resolutions.html</link>
      <pubDate>Wed, 29 Dec 2010 20:17:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/12/reviewing-and-renewing-resolutions.html</guid>
      <description>My career I&amp;rsquo;m still working on the same projects as I was last year: Firestation Antwerp and Ghent. This year we did not build a lot of brand new things, but we have added a decent amount of new functionalities. Next to that there were a bunch of bugs to fix and technical debt to pay off. I learned a lot from the mistakes we made and refactoring makes you really think about what good and clean code should look like.</description>
    </item>
    
    <item>
      <title>HTML5: Exception handling with the Geolocation API</title>
      <link>https://jefclaes.be/2010/12/html5-exception-handling-with.html</link>
      <pubDate>Sun, 26 Dec 2010 20:30:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/12/html5-exception-handling-with.html</guid>
      <description>In my previous post on the Geolocation API I passed in a PositionErrorCallback to the geolocation.getCurrentPosition() method. When I received this callback I displayed a generic message informing the user something went wrong. In real-world scenarios you probably want the message to be more specific. You might also want to call a specific fallback method depending on what went wrong.
This is where the PositionError argument of the PositionErrorCallback comes in handy.</description>
    </item>
    
    <item>
      <title>HTML5: The Geolocation API is scary (good)</title>
      <link>https://jefclaes.be/2010/12/html5-geolocation-api-is-scary-good.html</link>
      <pubDate>Sun, 19 Dec 2010 17:30:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/12/html5-geolocation-api-is-scary-good.html</guid>
      <description>I read about the HTML5 Geolocation API in the Pro HTML5 Programming book a while ago, and decided to play with it on this lazy Sunday.
Using the Geolocation API to make a one-shot position request is very straight-forward. Get a reference to the navigator.geolocation object and call the getCurrentPosition() method, passing in at least a PositionCallback. In this example I&amp;rsquo;m also passing in a PositionErrorCallback. In the PositionCallback you can examine the properties of the position object.</description>
    </item>
    
    <item>
      <title>HTML5 selectors and jQuery</title>
      <link>https://jefclaes.be/2010/12/html5-selectors-and-jquery.html</link>
      <pubDate>Sun, 12 Dec 2010 13:09:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/12/html5-selectors-and-jquery.html</guid>
      <description>In my first post on the HTML5 javascript Selector API I wondered how the new methods querySelector() and querySelectorAll() would influence jQuery.
At the time, I couldn&amp;rsquo;t find any information on the subject, but yesterday I found out that jQuery has been taking advantage of these new methods since version 1.4.3.
From the release notes..
 The performance of nearly all the major traversal methods has been drastically improved. .closest(), .</description>
    </item>
    
    <item>
      <title>HTML5: Drawing images to the canvas gotcha</title>
      <link>https://jefclaes.be/2010/12/html5-drawing-images-to-canvas-gotcha.html</link>
      <pubDate>Sun, 05 Dec 2010 19:55:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/12/html5-drawing-images-to-canvas-gotcha.html</guid>
      <description>While I was playing with the Canvas API I came across a weird issue: I was trying to draw an image to the canvas, but the image failed to render very often.
Have a look at the source. Do you spot the problem?
&amp;lt;!DOCTYPE html&amp;gt; &amp;lt;html&amp;gt; &amp;lt;head&amp;gt; &amp;lt;title&amp;gt;HTML5: Canvas&amp;lt;/title&amp;gt; &amp;lt;script type=&amp;#34;text/javascript&amp;#34;&amp;gt; window.addEventListener(&amp;#34;load&amp;#34;, draw, true); function draw(){ var canvas = document.getElementById(&amp;#39;canvas&amp;#39;); var context = canvas.getContext(&amp;#39;2d&amp;#39;); var img = new Image(); img.src = &amp;#34;logo.</description>
    </item>
    
    <item>
      <title>HTML5: More on selectors</title>
      <link>https://jefclaes.be/2010/12/html5-more-on-selectors.html</link>
      <pubDate>Sun, 05 Dec 2010 13:15:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/12/html5-more-on-selectors.html</guid>
      <description>Last weekend I blogged on new addittions to the javascript Selector API: querySelector() and querySelectorAll(). These two new methods enable you to find elements by matching against a group of selectors. I only scratched the surface in the previous post, that&amp;rsquo;s why you can find a few more examples in this post. These examples should demonstrate the power and ease of use of the new Selector API features. It&amp;rsquo;s impossible to show you all of the selectors usages in just one post, that&amp;rsquo;s why I strongly encourage you to have a look at the W3C Selectors specifications.</description>
    </item>
    
    <item>
      <title>HTML5: New in the javascript Selector API</title>
      <link>https://jefclaes.be/2010/11/html5-new-in-javascript-selector-api.html</link>
      <pubDate>Mon, 29 Nov 2010 19:30:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/11/html5-new-in-javascript-selector-api.html</guid>
      <description>Because I finally got the MCTS 70-536 certification out of the way, I can start experimenting with some fun stuff again. One of the things on the top of my list is HTML5. I started reading the book Pro HTML5 Programming, so expect more posts on HTML5 in the near future.
In this post I will show you two new methods in the javascript Selector API which are extremely useful to find elements.</description>
    </item>
    
    <item>
      <title>Trip Report Denmark (Part 2)</title>
      <link>https://jefclaes.be/2010/10/trip-report-denmark-part-2.html</link>
      <pubDate>Thu, 14 Oct 2010 15:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2010/10/trip-report-denmark-part-2.html</guid>
      <description>If you missed the first part of this trip report, you can find it here.
Funen After three days of Copenhagen we stayed at Funen for two days. This is the smallest of the three big islands of Denmark. Our motel was in a small town called Faaborg.
During these two days in Funen the most impressive attraction we went to see was the Egeskov Castle. This castle is Europe&amp;rsquo;s best preserved Renaissance water castle.</description>
    </item>
    
    <item>
      <title>Trip Report Denmark (Part 1)</title>
      <link>https://jefclaes.be/2010/10/trip-report-denmark-part-1.html</link>
      <pubDate>Wed, 13 Oct 2010 20:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2010/10/trip-report-denmark-part-1.html</guid>
      <description>Last month me and my girlfriend went on a holiday to Denmark for a week. We had a great time, visited a lot of places and took hundreds of pictures. In this post you can find a trip report containing the best pictures and tips on places to see.
Copenhagen The first three days of this holiday we visited Copenhagen. These three days were the most interesting, but also the most intensive days of the holiday.</description>
    </item>
    
    <item>
      <title>Things good to know about SQL State Server</title>
      <link>https://jefclaes.be/2010/09/things-good-to-know-about-sql-state.html</link>
      <pubDate>Thu, 23 Sep 2010 19:31:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2010/09/things-good-to-know-about-sql-state.html</guid>
      <description>While installing a SQL State Server last week, I came across a few things worth sharing about the installation and use of SQL State Server.
Finding a good tutorial There are lots of tutorials out there on how to install SQL State Server but most of them are not great. To do a basic installation you only need this MSDN documentation on how to run the Aspnet_regsql.exe tool and edit your web.</description>
    </item>
    
    <item>
      <title>Tripping in Holland. Honey, who shrunk Holland?</title>
      <link>https://jefclaes.be/2010/07/tripping-in-holland-honey-who-shrunk.html</link>
      <pubDate>Wed, 21 Jul 2010 17:30:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2010/07/tripping-in-holland-honey-who-shrunk.html</guid>
      <description>People who follow me on Twitter might have seen my tweets about going on a weekend to Holland with some friends. Next to excessive eating and drinking, we took the time to do some sightseeing in The Hague.
The sight which gave us the most interesting pictures is Madurodam. Madurodam is a miniature city featuring the most famous Dutch buildings and landmarks. Hope you enjoy these pictures!</description>
    </item>
    
    <item>
      <title>Switching with non-constant cases in C#</title>
      <link>https://jefclaes.be/2010/07/switching-with-non-constant-cases-in-c.html</link>
      <pubDate>Wed, 14 Jul 2010 22:25:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2010/07/switching-with-non-constant-cases-in-c.html</guid>
      <description>Last week I came across a scenario where I wanted to switch over non-constants (aka variables), but while I was compiling I got Compiler Error CS0150 (A constant value is expected). This is one of those things I always forget. You can&amp;rsquo;t use variables in your case statements because the C# compiler doesn&amp;rsquo;t allow you to. It&amp;rsquo;s very logical though, the compiler forces you to use constants because otherwise there is no way of knowing there are equal case statements.</description>
    </item>
    
    <item>
      <title>Handling the AggregateException</title>
      <link>https://jefclaes.be/2010/05/handling-aggregateexception.html</link>
      <pubDate>Sun, 23 May 2010 13:10:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2010/05/handling-aggregateexception.html</guid>
      <description>Last week I showed you how you can use the AggregateException to apply consistent exception handling in batch operations. You can find that post here.
Bart De Smet read that post and pointed out that I should check out the Handle method of the AggregateException.
The Handle method As found in the MSDN documentation.
Description
Invokes a handler on each Exception contained by this AggregateException. Parameters
System.Func&amp;lt;Exception, Boolean&amp;gt; predicate The predicate to execute for each exception.</description>
    </item>
    
    <item>
      <title>Exception handling in batch operations with the AggregateException</title>
      <link>https://jefclaes.be/2010/05/exception-handling-in-batch-operations.html</link>
      <pubDate>Sat, 15 May 2010 18:34:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2010/05/exception-handling-in-batch-operations.html</guid>
      <description>Doing batch operations and elegantly handling exceptions is a problem which every developer has faced before. In .NET 3.5 or older there is no out-of-the-box solution to handle exceptions in these types of scenarios, without being inconsistent to the normal flow of exception handling. .NET 4 introduces the AggregateException; an exception representing multiple exceptions. The AggregateException was introduced in the first place to be used with the parallel framework, but it can be used in other scenarios as well, such as batch operations.</description>
    </item>
    
    <item>
      <title>Trip Report Czech Republic</title>
      <link>https://jefclaes.be/2010/04/trip-report-czech-republic.html</link>
      <pubDate>Mon, 12 Apr 2010 20:16:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2010/04/trip-report-czech-republic.html</guid>
      <description>Last week my girlfriend and I went on a short holiday to the city of Plzeň in the Czech Republic. In this post you can find a small trip report.
Roadtrippin&amp;rsquo; Minutes after leaving home we discovered an unpleasant surprise; my Tom Tom has no map of the Czech Republic. Good thing that people used to print this stuff on paper. After consulting a paper map of Europe we did have an idea which direction to follow.</description>
    </item>
    
    <item>
      <title>Cannot Start Service from the command line or debugger. A Windows Service must first be installed (using installutil.exe)..</title>
      <link>https://jefclaes.be/2010/03/cannot-start-service-from-command-line.html</link>
      <pubDate>Sat, 13 Mar 2010 16:36:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/03/cannot-start-service-from-command-line.html</guid>
      <description>When you create a new Windows Service project and try to debug it, Visual Studio will show you a Windows Service Start Failure with the message Cannot Start Service from the command line or debugger. A Windows Service must first be installed (using installutil.exe) and then started with the Server Explorer, Windows Services Administrative tool or the NET START command..

The trick my team and I use to workaround this problem, makes use of the service Debug flag.</description>
    </item>
    
    <item>
      <title>Book review: Object-Oriented JavaScript</title>
      <link>https://jefclaes.be/2010/02/book-review-object-oriented-javascript.html</link>
      <pubDate>Mon, 22 Feb 2010 19:47:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/02/book-review-object-oriented-javascript.html</guid>
      <description>Although I&amp;rsquo;ve made my feet wet with various JavaScript frameworks, I am not a JavaScript hero at all. This might be one of the disadvantages of being a WebForms developer and having great toolkits at hand like the AJAX Control Toolkit and Telerik RADControls.
Because you really can&amp;rsquo;t call yourself a webdeveloper without having some understanding of JavaScript I decided to order Object-Oriented Javascript by Stoyan Stefanov.
This book really handles the language itself.</description>
    </item>
    
    <item>
      <title>Webforms lessons learned the hard way (Part 2)</title>
      <link>https://jefclaes.be/2010/02/webforms-lessons-learned-hard-way-part_15.html</link>
      <pubDate>Mon, 15 Feb 2010 17:43:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/02/webforms-lessons-learned-hard-way-part_15.html</guid>
      <description>If you missed part 1, you can find it here.
Use the built-in goodies ASP.NET Webforms has a lot of good stuff built into it. Do your homework before you start building the next big Webforms thing! A perfect example of this is ASP.NET Membership. ASP.NET provides an out-of-box membership solution. I&amp;rsquo;ve seen people who were to lazy to do some research or thought they could do better and ended up with a solution which put its doors wide open to people with bad intentions.</description>
    </item>
    
    <item>
      <title>Webforms lessons learned the hard way (Part 1)</title>
      <link>https://jefclaes.be/2010/02/webforms-lessons-learned-hard-way-part.html</link>
      <pubDate>Sun, 14 Feb 2010 16:22:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/02/webforms-lessons-learned-hard-way-part.html</guid>
      <description>I&amp;rsquo;ve been spending a lot of my days in Webforms the last two years. In this post I want to share some best practices I&amp;rsquo;ve learned the hard way over these years. A lot of MVC developers might think this post comes a bit late (who still cares about Webforms?!), I do think (in the real world) a lot of the ASP.NET developers are still using Webforms. This post is directly targeting them.</description>
    </item>
    
    <item>
      <title>Log4Net: log.Debug(String.Format()) versus log.DebugFormat()</title>
      <link>https://jefclaes.be/2010/01/log4net-logdebugstringformat-versus.html</link>
      <pubDate>Wed, 20 Jan 2010 20:30:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2010/01/log4net-logdebugstringformat-versus.html</guid>
      <description>Log4net is one of the most popular opensource logging frameworks available in the .NET world. I&amp;rsquo;ve been using this framework for over a year now, and today I discovered something new.
I often use string.Format() to format my log messages. Earlier this morning I made a typo formatting my message and an Exception was thrown in the beginning of my method which caused the application flow to break. You can avoid this by using the DebugFormat() method.</description>
    </item>
    
    <item>
      <title>Looking back, moving forward (New years post)</title>
      <link>https://jefclaes.be/2009/12/looking-back-moving-forward-new-years-post/</link>
      <pubDate>Mon, 21 Dec 2009 18:57:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2009/12/looking-back-moving-forward-new-years-post/</guid>
      <description>In this post I&amp;rsquo;m going to reflect on the year that&amp;rsquo;s almost finished and the year to come.
I came up with a few topics that are worth discussing in this post.
My career I don&amp;rsquo;t think I ever mentioned where I work. The first of January I will be working 18 months for Ferranti. The only company I&amp;rsquo;ve worked for since I graduated.
The first project I&amp;rsquo;ve ever worked on was a rather big one.</description>
    </item>
    
    <item>
      <title>Response.RedirectPermanent in .NET 3.5 and older</title>
      <link>https://jefclaes.be/2009/12/response.redirectpermanent-in-.net-3.5-and-older/</link>
      <pubDate>Sat, 05 Dec 2009 17:50:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2009/12/response.redirectpermanent-in-.net-3.5-and-older/</guid>
      <description>One of the new features in ASP.NET 4.0 is permanently redirecting to a page using Response.RedirectPermanent.
 It is common practice in Web applications to move pages and other content around over time, which can lead to an accumulation of stale links in search engines. In ASP.NET, developers have traditionally handled requests to old URLs by using by using the Response.Redirect method to forward a request to the new URL. However, the Redirect method issues an HTTP 302 Found (temporary redirect) response, which results in an extra HTTP round trip when users attempt to access the old URLs.</description>
    </item>
    
    <item>
      <title>Book review: Professional Refactoring in C# &amp; ASP.NET</title>
      <link>https://jefclaes.be/2009/11/book-review-professional-refactoring-in.html</link>
      <pubDate>Tue, 17 Nov 2009 19:37:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2009/11/book-review-professional-refactoring-in.html</guid>
      <description>Three months ago I was looking up to refactoring a legacy ASP.NET Webforms application. Although I was familiar with refactoring, I ordered &amp;ldquo;Professional Refactoring in C# &amp;amp; ASP.NET&amp;rdquo; by Daniejel Arsenovski to get deeper into refactoring.
The title Although the title states &amp;ldquo;Professional&amp;rdquo;, I think this book should find its main audience in coding novices. Another problem with the title is the word ASP.NET in it. The book has one chapter covering ASP.</description>
    </item>
    
    <item>
      <title>My trip to Madrid in ten pictures</title>
      <link>https://jefclaes.be/2009/11/my-trip-to-madrid-in-ten-pictures.html</link>
      <pubDate>Mon, 09 Nov 2009 20:30:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2009/11/my-trip-to-madrid-in-ten-pictures.html</guid>
      <description>Last week I went to Madrid with my family-in-law to visit my girlfriend&amp;rsquo;s brother and cousin.
Although our stay there was rather short (only four days), we visited some of the most impressive places in Madrid:
 - Stadium Real Madrid
 The Royal Palace Prado Museum Queen Sofia Museum Buen Retiro Park Plaza Mayor &amp;hellip;   Stadium Real Madrid 

Pay attention to the stitching Jesus in first place.</description>
    </item>
    
    <item>
      <title>Why code reviews should be a team thing</title>
      <link>https://jefclaes.be/2009/08/why-codereviews-should-be-teamthing.html</link>
      <pubDate>Sun, 23 Aug 2009 19:22:00 +0200</pubDate>
      
      <guid>https://jefclaes.be/2009/08/why-codereviews-should-be-teamthing.html</guid>
      <description>Often code reviews are done by one person, the technical lead of your team.
In my opinion it&amp;rsquo;s better to make each developer of your team do code reviews.
My arguments  Having all developers do code reviews leads to discussions about what coding standards should be used.. Leading to well-documented standards. Each developer is forced to understand the workflow of an application which isn&amp;rsquo;t his, which expands his domain knowledge.</description>
    </item>
    
    <item>
      <title>Stored Procedures: Make them or break them</title>
      <link>https://jefclaes.be/2009/01/stored-procedures-make-them-or-break.html</link>
      <pubDate>Sun, 15 Feb 2009 18:58:00 +0100</pubDate>
      
      <guid>https://jefclaes.be/2009/01/stored-procedures-make-them-or-break.html</guid>
      <description>I&amp;rsquo;ve been thinking about the use of stored procedures lately.
Some questions that popped up in my head: What are the advantages/disadvantages? When and how should they be used? Will they extinct with LINQ to SQL becoming more and more popular? Why should you store your queries in your database, instead of in your code..
I asked the opinion of a few ASP.NET/.NET professionals. Hope you find this interesting!
Kris Van Der Mast (Blog)  Since I&amp;rsquo;m a consultant I have to go with the specifications of my clients.</description>
    </item>
    
  </channel>
</rss>