ElmahR reached v0.6, and a lot of improvements happened since previous version, most of them on the UI. Finally we had time to concentrate on the visual aspects of the dashboard, trying to come up with something more reactive, better at bringing the right information and at scaling along with the number of monitored applications. This last issue has been worrying us the most, it's not easy to accomodate the potentially quite big volume of info that ElmahR handles. We let ourselves be inspired by Twitter web site user experience, and we took advantage of the Twitter bootstrap framework to build a responsive layout. It is a very interesting framework, it allowed us to greatly improve how the dashboard looks like, and now we have better support of different form factors and browsers. Now IE9 is well supported too, while we still have problems with older versions, we'll try to target IE7 and IE8 in next iterations. Twitter bootstrap is quite simple, but it can also help deliver sophisticated UIs and to do that it can get pretty complex. We cannot really say we understood everything of it, but we also wanted to deliver soon, so we found a quite good and quick compromise analyzing a sample application and modifying it to our needs. You might notice it in the css files, one of them is still quite 'in progress' and it also contains stuff coming from the original sample and that we do not really use, but it's like that because we'll try to understand more of it in the next days.

Yesterday I blogged and twitted about the v0.5 release of ElmahR, and after a few retweets an amazing sequence of interactions started to happen! In the last 24 hours I received many retweets, new Twitter followers appeared and my tweet has been favorite by several people. The demo web site received hundreds of simulated errors (which actually helped me to spot at least 2 bugs :) ), my blog post has been visited by more than 400 unique visitors, and ElmahR repository has 4 new followers. And there's more, I became member of the Software Development list, and today ElmahR was on the home page of The Morning Brew, and in a very good company indeed! Those are not particularly big numbers for most of you, of course, but for me they are :)

ElmahR v0.5 has just been pushed on the demo site and in the source repository. A global errors feed has been added, and now the applications resume shows for each source what the last error has been and how many errors have been raised.

In this short post belonging to the series about extending the world of Linq, I'll talk about an interesting way to leverage anonymous types through a pattern we use at work. We all know what they are, and we all know their most important limitation: once defined, an anonymous type cannot be passed to other functions or returned to the caller of the function which defined it (we are talking about language features, and we don't consider any technique based on reflection or other knowledge about the runtime internal structure of such types). It is quite common to write functions which return complex values, and if we want to make them reusable we need at some point to define some structure representing the result of the computation. We could use tuples, but they are not that good at communicating information, so we must surrender and define small DTOs just to represent those answers, just because anonymous type cannot cross the boundaries of a function. But is that completely true?

Short post, I just pushed v0.3 of ElmahR in the source repository. This release has been about Javascript cleanup, making code much more modular and with a draft plugin structure. I also update jQuery to 1.7.1, and introduced RequireJS for handling dependencies, but so far I just played with it and it's not yet used, this will happen in the next days along with some UI improvements. After that I'll improve the HTTP traffic between client and server, adding more but optimized roundtrips, and then I'll move to work on the server side of the system.

After releasing Elmahr v0.2, I think it's time to describe with more details what it is, how it's done and what are my plans for the next releases. ElmahR is a web dashboard where you can aggregate several monitored applications; adding them to ElmahR configuration will enable them to post error events, which will show them on all the connected client dashboards in real-time.

This is just a quick announcement about the fact that in the last 2 days I released ElmahR v0.2 (you may call it 'alpha'). ElmahR is a real-time aggregating dashboard for ELMAH, based on a module I wrote to in the official ELMAH Sandbox, and leveraging SignalR for the async real-time communication. I already described how I came up with idea of this project, and in the last weeks I've been working on it to see if I could realize it. I'm quite happy with the results so far, so I decided to share it, let's see if you find it as much interesting as I did.
The project is still very basic and it's missing features, but at the end of the day it's working, and it's been real fun to work on it because it allowed me to try a lot of great stuff out there:

During the last few days I've been working on a new idea. I've been listening and reading about SignalR since a few months, and 2 weeks ago I attended a very interesting session by Marteen Balliauw about it at the UGIALT.NET conference in Milan. At the same time I'm an ELMAH user since a while, and I have the pleasure to share my working hours and my lunches with its author Atif. So, when I was in my car coming back from the conference to where I live, and despite (or maybe thanks to...) a bad cold that was hitting me, I had this idea to join these two libraries to offer real time and interactive experience to the logging capabilities that ELMAH offers. This week I started this experiment and I had a lot of fun working on it.

First, I cloned the ELMAH Sandbox project repository following the recommended guidelines, and inside it I wrote a new ErrorPostModule for ELMAH. This module is very simple, and so far its implementation is still very basic, its goal is to process an unhandled exception that occurred in the host application and post its Json representation to a specified destination. When you have this module available, in your ELMAH-enable applications you can activate it adding a configuration key like this one:

As promised, here you can find the source code relative to the discussions we made so far:

Last time we introduced a new simple exercise, where we have a computation which might fails and we want to to try to remove all the noise that the error handling introduces all around the algorithm. We talked about Monads (in a very simplified way) and we defined a way we could write our computation inside a Linq expression, using a Monad to isolate the unwanted error handling code. What we still have to do is actually implement this new Monad and see how we can leverage this concepts and strategies to reach our goal.

So far in our series we have seen how Linq is a world that can be extended if we craft our types the right way. We learned that Linq is definitely not just for IEnumerable or IQueryable, and I'm more and more convinced that what's most interesting about Linq is the way it guides you to write more functional code. I'm not a functional programmer (yet), so please do not expect too much knowledge about that from my posts, but I'm slowly gaining a more functional view on things, and I'm feeling that it's a good thing to have. There are a few aspects of functional programming that Linq tries to enforce:

In the previous episode of this short series, I showed how you can define a type in a way that enables it to participate to Linq queries. Linq query syntax defines a set of operators, which are mapped to methods that types involved in a Linq query must provide. If they natively do not, we can still make them work because extension methods come to the rescue. How those methods should be named and shaped is clearly documented, and it would be too much to be explained here, so I will skip these details. I'll go back to our exercise and I'll use it to give you some more details about a couple of interesting points.

After the general introduction to this short series of post, I would like to set up a sort of roadmap, defining the goals that I have while writing this stuff. But first, a sort of disclaimer: I'm not a big expert of these things at all, and I'm quite new to this kind of approach, but that's exactly the reason why I want to write about it, to illustrate things from the point of view of someone who's really learning to use this new mindset and the related techniques, because I know there are a lot of guys like me out there :) The code I will show will be written by myself in a sort of "learn by trial" process, but it will be strongly inspired by several sources, which I will try to mention as most precisely as possible. If someone reading these posts will find errors or omissions his comments will be welcomed.

After a few months I'm back to write on my blog, but to be honest I had a good excuse, since my wife and I have dealt with a move abroad (I'll talk about it separately), which is not exactly something trivial. However, we are slowly returning to normal, and today I managed to get a little time to write this post.

In the last few days I've been struggling with a quite hard task: introducing some caching mechanism in an existing and complex infrastructure, which is already using AppFabric caching (aka: Velocity) in some other areas.

Yesterday I had an interesting chat with my colleague and friend Felice, from the famous "Fatica Labs", about an idea I had a couple of months ago.