Juri's TechBlog

Detecting Location Redirects from JavaScript

noreply@blogger.com (Juri Strumpflohner) — Thu, 24 May 2012 05:53:00 +0000

A common scenario for using the HTTP Location response header is during an authentication process where some kind of filter redirects to a login page in case when the user is not or no more authenticated. Handling such redirects from JavaScript turned out to be not so simple as it might initially seem. Stackoverflow has already a post on that and here (or on SO) is how I solved it in the end.

My scenario is basically the following. I have an ISA server which intercepts all of the requests and verifies the user's authentication. In case when the user isn't logged in it responds with a 302 and adds the location header to my login page.

The Initial Approach

In the case of a rich JavaScript client you would then have something like

$(document).ajaxComplete(function(e, xhr, settings){
    if(xhr.status === 302){
        //check for location header and redirect...
    }
});

But unfortunately the browser handles location redirects completely himself, wherefore the ajaxComplete callback won't fire with the 302 status code, but instead it will fire on the location redirect target (when that redirect already happened successfully). As a result, the approach before obviously won't work.

The Solution

The solution is a bit hacky but it works and I didn't found a better one so far (comment if I'm wrong). Basically what you do is to inject a custom header in your Login page for which you then listen on your client-side. The trick is to inject a header like

LoginPage: http://www.mydomain.com/Login

where the url is the one of the invoked Login page due to the location redirect. On the client side you can now check for the presence of the header like

if(xhr.status === 200){
    var loginPageHeader = xhr.getResponseHeader("LoginPage");
    if(loginPageHeader && loginPageHeader !== ""){
        window.location.replace(loginPageHeader);
    }
}

You might wonder why I included the url directly in the header value. The problem is that you have no way of detecting the URL of the redirected request in the ajaxComplete callback. You just get the initial one you started, that is, when you execute a GET /person/1 and you're no more logged in (because the session expired) and the server sends you a 302 redirect to /login, then you'll see the /person/1 as the url in your ajaxComplete callback although the content of the response is the one of your login page. That's why I directly included the url in my custom header.

Here's my explanation on SO: http://stackoverflow.com/a/10717647/50109

Architecting for Failure at the Guardian

noreply@blogger.com (Juri Strumpflohner) — Sun, 20 May 2012 16:03:00 +0000

Architecting for the Failure, a presentation of this year's QCon London 2012. Michael Brunton-Spall gives some insights into how they moved their architecture at the Guardian from a monolith system to a system composed of "microapps".

Watch it over at InfoQ:
http://www.infoq.com/presentations/Architecting-for-Failure-at-the-Guardian

Visual Studio: Set the Build Action for an Entire Folder

noreply@blogger.com (Juri Strumpflohner) — Mon, 14 May 2012 06:54:00 +0000

I'm sure you already encountered this problem, right? In my specific case I have a folder called "frontend" with a bunch of JavaScript, CSS and view template (EJS) files; my rich JavaScript client basically. I just need them when starting my app in my local Visual Studio development server but they should not be copied when publishing. Why? Because they walk through a Minifier and Linter before. The solution: set the Build Action to None. That won't work on an entire folders however, sigh...

Since Visual Studio doesn't provide us such option, the solution is basically to open your .csproj file with your preferred editor and to replace all occurrences of

<Content Include="frontend\snip\snip\somefile.js" />

with

<None Include="frontend\snip\snip\somefile.js" />

I'll leave the regex for you ;).

I just did it with Sublime Text and that's just amazing. Basically you do a Ctrl+F and enter your regex. Then you click the "Find All" button and it will place a cursor automatically on all of the found occurrences such that you can just edit those lines. Awesome!!

Scaling Android Emulator Size: Without using Eclipse

noreply@blogger.com (Juri Strumpflohner) — Thu, 03 May 2012 07:17:00 +0000

As you might have read following my previous post I'm currently experimenting with mobile web solutions. In such a case, having an Android emulator is quite comfortable for quickly testing your solution. Personally though, I hate the default emulator skin, mainly also because it takes up quite a large portion of your screen. Hence, I normally use a custom emulator skin. But there is the problem of the scaling the size properly as the default settings will most probably go out of your screen.

A couple of years ago I wrote a blog post on how to tune your Android emulator with a custom skin. In that post, I also described on how to scale it properly, by adding the -scale option to the command line arguments from within the Eclipse Run Configuration dialog.

However, if you're only interested in the emulator itself, you may start it by launching the AVD manager directly. In that case, the scale parameter can be directly set when launching your AVD:

Btw, should you have problems connecting to the Internet from your emulator, it might be due to the proxy settings of your (company) network. Have a look at this post then, it might help you.

HTML5 version Android: Apps or Web for mobile development??

noreply@blogger.com (Juri Strumpflohner) — Thu, 26 Apr 2012 06:49:00 +0000

This is a hotly discussed topic recently. The web is now a fully-capable platform and it's getting better and better as the HTML5 standard advances. And that's actually also the point why we're even here to discuss topics like this. QCon London this year clearly showed the trend which is going into the HTML5 + JavaScript direction rather than for native.

If it's for me personally, then I'd say you "go and develop a fancy nice Android app". Why? Because you have its full power at hand, a market where to deploy it and hence a nice potential audience which is going to consume it. That's the point! Your range of target consumers. I'm saying this, though, because I'm and Android fanboy, I know how to develop Android apps and I love to develop for it!

But if you're in the industry, more specifically, in the web industry, things change immediately. A major fact there are the human resources and the required knowledge you have to deal with/acquire. That's exactly the scenario where I'm currently in. As an architect in a web development company, I cannot just say "come on, lets open another development branch, hire good mobile devs or train existing ones". Well, I could, but it wouldn't be the most economic way of doing things. Instead, what you aim to do is to reuse existing resources, in the form of knowledge and devs as much as you can. Because in the end, (at least for now) 80-90% of our focus will still be the web platform, but we have to be ready also for the remaining 10-20% allocated to the mobile part. And the latter one is growing enormously fast.

I predict that this year Apple will announce a new programming model for iOS which will be based on Javascript.

Read more

IMHO that would be great. Consider how many more people would start developing for iOS if they would be granted to develop in a language they know (JavaScript and HTML5) and to publish their "web" mobile apps on the official market.

(More to come possibly on this topic on my blog here)

Using NuGet to Distribute Our Company Internal DLLs

noreply@blogger.com (Juri Strumpflohner) — Thu, 19 Apr 2012 13:00:00 +0000

Releasing new software has to be simple and super fast! That was not the case for our company-internal class libraries till a couple of month ago until I finally decided to take the time to optimize that release process.

At the company where I'm working at currently, we have an internal class library which bundles a series of utilities with the scope of helping devs doing their day-to-day job. So far so good, however, there has always been a thing that puzzled me right from the beginning was the cumbersome release process of that library. Creating a release bundle consisted in

incrementing the version number in the AssemblyInfo
building the library project in release mode
opening the bin folder
zipping the dlls
uploading the zip to our company-internal wiki page with a version history of the release

That's really tedious, isn't it? It sometimes took longer to create a new release than to fix a bug. So a couple of months ago I decided to optimize that: using NuGet. If you're a .Net dev you for sure already heard about it.

NuGet is a Visual Studio extension that makes it easy to install and update third-party libraries and tools in Visual Studio. When you use NuGet to install a package, it copies the library files to your solution and automatically updates your project (add references, change config files, etc.). If you remove a package, NuGet reverses whatever changes it made so that no clutter is left.

http://nuget.org/

The idea was to create a local, company-internal NuGet repository.

Setting up a company-internal NuGet Repository

That turned out to be simpler than expected. Creating a local NuGet repository is as simple as creating a folder on some network share and to deploy all of your NuGet packages there.

Configuring Visual Studio

In order for NuGet to also search on your private repo you need to add the URL to the repository in your NuGet Package Manager Settings under Tools > Library Package Manager > Package Manager Settings.

When you now invoke the Nuget Package Manager on a Visual Studio Project or Solution you should also see your private repo listed as a possible source:

You're ready! You can now start packaging your class libraries and dlls as NuGet packages.

Automate to the death?

I'm not going to write on how to create NuGet packages as NuGet has excellent docs on this. What I did is to create a .nuspec file for the class library and then a nice publishRelease.bat containing something like

msbuild Siag.Base.csproj /target:Rebuild /property:Configuration=Release 
nuget pack Siag.Base.csproj -Symbols -Prop Configuration=Release
move *.nupkg \\snip\snip\NuGetRepository

Releasing today means...

Incrementing the version number in the AssemblyInfo.cs
double-clicking on the publishRelease.bat

Like it! :)

Respecting "the Zone"

noreply@blogger.com (Juri Strumpflohner) — Thu, 05 Apr 2012 07:34:00 +0000

Respect when someone is "in the zone"! Don't disturb him if it's not necessary. The "context switch problem" is a known issue in the software development process. Zach Holman particularly mentioned this during his talk at this year's QCon. So what is it about? What's the "zone"??

You're coding, right? Do you know those times when you're extremely productive?? Usually when you're alone in the office or later in the evening when the others already left home?? It feels like you could rewrite the entire product in hours, right? It feels good!

And then there are those other situations, when you really need to finish that piece of software as other people are already waiting for you and you continuously get interrupted by your mates or by ad-hoc meeting requests, incoming IM messages etc...At the end of the day you mostly wrote a couple of lines and you're frustrated.

Zach Holman especially highlighted this during his presentation of "How Git Works" at QCon this year.

The best solutions happen when you're in the zone.

Slide 24 (if it doesn't redirect automatically)

Therefore, they want developers to be in the zone (slide 54) as long as possible. At GitHub they go even further:

Minimize distractions
No technical meetings (no standup, daily or planning meetings)
No in-person distractions (instead, ping over chat)
No managers (they just distract ;) )

Show you're in the zone!

While some of these concept might be difficult to realize in your day-to-day reality some should really be considered. Therefore, establish some kind of "respect for the zone". Clearly show your peers your currently "in the zone" and therefore you wouldn't like to be interrupted. How?

Wear a cap?
Take on your earplugs?
Add an IM status message?

It should be clear and understandable, though.

Respect others

And on the other side respect people being in the zone. Don't distract/interrupt them when it is not really necessary. We have async ways of communicating: email, IM pings...

Make sure you remain in the zone yourself!

But you also need to make sure you minimize distractions on your own. Prevent IMs from popping up, switch off all those social tools blinking and presenting you the latest activities of your peers, etc...Put on some music that helps you keeping focused.

Try to consider some of these aspects in your working environment!

Joining the DZone MVB Program

noreply@blogger.com (Juri Strumpflohner) — Tue, 03 Apr 2012 12:05:00 +0000

A couple of weeks ago I was kindly invited to join DZone as a MVB (Most Valuable Blogger). If you shouldn't already know, "DZone is a technology publishing company that produces valuable content for software architects and developers worldwide."

The MVB program builds mutually beneficial partnerships between DZone and community bloggers whose articles are of interest to the developer community. The program simplifies the process of publishing selected blog articles by MVB members onto DZone's network of development-focused editorial websites. Through this process, our MVBs enjoy substantially increased visibility and our audience enjoys great content.

There are a lot of amazing people participating at the DZone MVB program wherefore I'm very proud to be able to contribute also a bit of my (not always really so important and interesting) stuff there. This is a huge motivation to continue trying to publishing good quality content on my blog here.

So if you'd like to look by, here's my page ;)
http://www.dzone.com/user/999973
(So far there's no content there)

QCon London - My Personal Recap

noreply@blogger.com (Juri Strumpflohner) — Tue, 03 Apr 2012 05:53:00 +0000

From the previous posts (or from those on my Tumblr stream) you might have understood my participation at this year's QCon London. Actually it was my 1st QCon conference and I enjoyed it a lot. Here is a quick recap of my personal impressions.

First of all, being my 1st QCon, what I really liked was the fact there were no technology evangelists, no one stating that one technology/language is better than the other etc, but everything was a bit more generic, more high-level. There was a bunch of interesting stuff so I'll try to just focus on the ones that particularly caught my attention.

Simplicity

Keep things as simple as possible. Simplicity was definitely THE keyword of the conference. Don't create artwork architectures, create easy and simple ones. Devs need to deliver value and a good architecture should leverage that and not hinder them.

It's about trade-offs!

Dan North's talk about "Decisions, Decisions,..." highlighted the fact that every taken decision is about trade-offs. As such, while automated deploy is a known best practice, it's still a trade-off in that people (once the deploy is automated) might loose the knowledge of doing it manually. Hence, in certain circumstances you might even prefer a manual over an automated deploy just to keep things simple.

When you know you are trading off you can make informed decisions.
Dan North, QCon London 2012

Copy&Paste might be an option as well

Yep, you read right. You shouldn't always aim for factoring out logic as much as you can and to then reuse that same piece of logic in every possible place. Because, every time you factor out common logic, you create a new dependency as well. Obviously that doesn't mean to c&p all the logic around, if you have to fix a bug in 2 places you failed. Instead, what it means is to not over-reuse things. Often copy&pasting and removing the lines you don't need might work out better than taking in all the other logic (which is not needed in that specific scenario). The rational behind: don't take it to the extreme!

Feedback...

Keep the cycle short. While this might seem a quite obvious concept nowadays, especially when you're doing agile, it was a core concept throughout the whole conference. Integrate mechanisms in your development process that give you feedback as soon as possible. This starts from writing automated unit tests to setting up a proper build pipeline as outlined in the Continuous delivery training session from the Thoughtworks guys to Netflix's impressing metrics system.

Social

The social aspect of the whole software development process was another important factor. IMHO the "How GitHub Works" talk by Zach Holman was a highlight of this part. He highlighted some very important facts about how to create a pleasant working environment and how to properly coordinate a distributed (GitHub) team.

Beside those mentioned on his blog, some things I personally found interesting and valuable:

Celebrate events (releases, birthdays,...)
Have informal meetings, sit together, talk about interesting stuff
Have Tech Talks held by employees

"Leave the ego at the door"

When you join meetings or pair coding sessions or whatever discussions, leave your ego at the door. That's the only way to learn! While this might sound obvious, try it yourself the next meeting.

DevOps

DevOps is an often used term these days. In small teams/companies this is not really an issue as there might not be any dedicated staff just doing operation activities like server configurations, DBA work etc.. The larger companies get, the more difficult things become and the more arises the risk of building a gap between the development and operation teams.

"No way, my servers are fine, it's probably because they don't know how to code properly!"

Sounds familiar? Aren't we one team in the end?? This is a major issue! Dan North talked about one of the situations he experienced, where he personally joined the operations staff and worked there for a while, as a fully integrated team member. In this way he learned about the problems there and was able (due to his programming capabilities) to solve quite a bunch of issues by automating stuff. The same works vice-versa. An OP guy joining the dev team might get a better insight into the application architecture and hence be able to more fine-tune the servers. OP guys know how to configure, devs how to automate. The key is that both parts naturally fit each other and should benefit from that.

Architecture

Again, simplicity is the main key here. Don't create masterpiece architectures, but simple, extensible and understandable ones. That's the only key they'll be properly adopted.

Beside that, architects need to code. They need to use their own systems, see how they perform and optimize accordingly. This way an architecture can evolve. Everything else is bullshit and a waste of time.

Without going into detail any further, here are the 3 pics of the session with Simon Brown:

Technologies

From the technology point of view the major discussed topics of the conference were

Mobile Web apps with HTML5 and JavaScript instead of native ones
NoSQL and document based databases (like MongoDB)
JavaScript and HTML5

Here's the vote of the QCon attendees among which my personal one.

My Notes of the Conference

You can find my personal notes taken during the conference here.

Sharpening the Tools

noreply@blogger.com (Juri Strumpflohner) — Wed, 14 Mar 2012 07:05:00 +0000

This is a talk from Dan North about Sharpening the Tools at QCon 2010. I had the great pleasure to listen to this guy at this year's QCon (recap is in the drafts already and will be published soon btw). In this talk he picks out some tips on how to keep up with the technological evolvement and with tools.

#1 Practise the basics - He mentions to practice coding katas, code just for the purpose of fun, learn shortcuts (I'm a huge fan of them) and practice your shell-fu. Actually I'm currently just trying to practice a bit that last point by having installed cygwin on my Windows Work PC. Moreover I bought a Mac years ago, just for the purpose of also knowing the unix-side of the world. Another important point was to learn a new language that you don't need (at work). My personal one currently: nodejs and document databases (MongoDb).

#2 Learn from other people - Beside stalking experts, following people on Twitter and reading blogs etc, he also mentions to read code from others. Just go and clone some GitHup repo and read through the code.

#3 Understand trends - Build a network of people you listen to. I'm doing that through RSS and Twitter preferably, an extremely powerful tools for keeping up with technology. Try out new things when there is the possibility to. You have to know just enough to be able to understand when you need a given technology needs further investigation. Do you know what you don't know?

#4 Share knowledge - One of my favorite points in this talk. Blog about successes, it's not only that you're able to build a community, but mainly you're actively reflecting about what you were doing, the good and bad parts, doing retrospectives basically.

#5 Maintain your toolbox - Some tools might be disposable, being no more useful, or technologically deprecated. Use the "clothing" rule to update your tools.

#6 Learn how to learn - Understand how learning works. Luckily I had a good course about that at University. Quite interesting stuff about your head works out behind the scenes :).
Chunking up: Asking What for? to find the real reason behind doing something.
Example:
A: I'm cleaning the pot.
B: What for?
A: So I fill it with water.
B: What for?
A: So that I can have some tee.
B: What for?
A: So I can appease my thirst.

...then...chunk down again

A: I'm thirsty.
B: How?
A: Drink tea, drink water, go to Starbucks.
B: How else? (< chunking sideways)
A: Drink water.
B: How else?
A: Go to Starbucks.

Eat your own dogfood
Actively solicit feedback
"Listen like you don't know the answer"

Questions for an Enterprise Architect

noreply@blogger.com (Juri Strumpflohner) — Fri, 02 Mar 2012 22:00:00 +0000

Erik Dörnenburg answers: What is Enterprise and Evolutionary Architecture?, discussing 4 issues: Turning strategy into execution, Ensuring conformance, Where do the architects sit? Buying or building?

A very nice talk I'd like to share here on the blog. It's essentially about architecture, especially targeting enterprise architecture, the do's and don'ts etc.

A nice quote regarding the often mismatched metaphor about the "architects" role:

What I want to call myself but couldn't get it through our departments was...I wanted to call myself a gardener. I'm sowing seats and I'm growing new plants and I am tending to them, making sure they're alright, making sure they have enough water. Some are more easy, some more difficult. [...] The gardener metaphor works much better than the architects metaphor but it doesn't sound as cool.

It really should be like that. An architect should be one trying to use his competencies to make things easier, to help solve problems at a higher level, but at the same time he should "eat his own dog food" (it is this like you're saying it, right?). Imposing an architecture at a high level, forcing it to be implemented is completely non-sense. An architect needs to work with the system he designs, basically he needs to experience it.

I Want the Cursor to be placed in the 1st empty Textbox!

noreply@blogger.com (Juri Strumpflohner) — Fri, 17 Feb 2012 06:46:00 +0000

You develop a webapp, you have a couple of input fields and buttons on your page. Then the requirement arrives. The customer wants his data to be auto-filled once he enters some identification number (the italian fiscal code). And then, when the data has been filled correctly, he wants the focus to be placed in the 1st empty text box in order to accelerate any further elaboration on that data. Oh ...man!

Well, the customer is the boss, right? If you live in the ASP.net WebForms world, such features immediately scare every developer. To realize them you have to deal with auto-postbacks, page refreshes, viewstate....all in all it ends in a mess to code, and it's a pain for the end-user. Let's not speak about UpdatePanels here, ok? Basically, you have to realize it in JavaScript to get a better user-experience. The problem is that if you have a hybrid situation where you mix JavaScript code with ASPX/ASCX code, it gets a little messy. You have to remember the generated ASP ClientIDs and correctly integrate them in your JavaScript code.

To not completely get lost in this post :), what I wanted to express is how easy it is to implement all this in JavaScript making use of jQuery:

$("#divPersonData").find("input:text[value='']:visible").first().focus();

Setting the focus to the first empty field is really just fun, right?

The essence of this post is that the UI experience gets more and more important in nowadays webapps. Just look around, Twitter, Trello, Gmail,...Think about it if you still live in the somewhat more traditional space of web development.

Update:
You might want to take a look at the HTML5 autofocus attribute here.

Sequential Asynchronous Processing with jQuery Deferreds

noreply@blogger.com (Juri Strumpflohner) — Mon, 13 Feb 2012 07:01:00 +0000

Asynchronous processing is one of the most difficult things for devs to understand when switching from the more traditional web programming pattern to a more client-server like model when creating rich JavaScript single-page apps. It involves a lot of passing callbacks around which makes the code ugly to ready and more complex. With the introduction of jQuery Deferred this hasn't to be the case any more!

jQuery Deferreds have been introduced with jQuery v1.5 and are a really nice mechanism for handling such asynchronous processing situations. Such asynch processing does not necessarily have to be an ajax call, but might also involve some operation that waits for an external event, such as a user interaction.

For instance consider the following control flow:

The user clicks a button.
A popup should appear asking the user for some information. If he provides the info, step 2 should be called.
An ajax call is done to the server, if the call succeeds, step 3 should be called
The data from the ajax call should be processed and on success the final state should be invoked.
The final success state.

Obviously, if in any of those states the operation fails or the user cancels the operation, the final state should never be reached, but rather some failure state should be called.

How would you implement this? With callbacks? A nightmare...I'm not even going to implement it as the result would be totally unreadable, not to speak about maintainability of the code. Instead, with the jQuery Deferred object, the result might look as shown in this dummy jsfiddle example:

Note, I consciously didn't properly refactor the code in order to not "hide" anything for the purpose of this demonstration here.

This reminds me a bit of the C# Task API with its ContinueWith etc methods.

References:
http://msdn.microsoft.com/en-us/scriptjunkie/gg723713.aspx

ASP.net MVC3: Doesn't Deserialize Nullable Properties from Json

noreply@blogger.com (Juri Strumpflohner) — Tue, 07 Feb 2012 07:08:00 +0000

A couple of days ago I noticed that the Nullable properties of a C# object were not properly deserialized when posting back a Json object to an MVC3 action. It seems like this is a bug in the JavaScriptSerializer used by MVC3 to serialize/deserialize Json data.

This behavior is quite nerving as you probably have a lot of nullable properties, often resulting directly from the underlying data structure in the DB (especially in a data-base first case with EF). So one solution might be to create your separate ViewModels and somehow handle the mapping of the nullable properties through those. Extremely smelly!

While browsing for a potential solution I came across this blogpost. According to the author of the post, apparently the DataContractSerializer doesn't have this problem. So what he does is to create an MVC3 ActionFilter for intercepting the call to the Action method and then to deserialize the arriving Json data using the DataContractSerializer.

public class JsonModelBinder : ActionFilterAttribute
{
    public JsonModelBinder()
    {}
         
    public Type ActionParameterType { get; set; }
    public string ActionParameterName { get; set; }
         
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        HttpRequestBase request = filterContext.HttpContext.Request;
        Stream stream = request.InputStream;
        stream.Position = 0;
        filterContext.ActionParameters[ActionParameterName] =
                        (new DataContractJsonSerializer(ActionParameterType)).ReadObject(stream);
    }     
}

The real action method then looks as follows:

[HttpPost]
[JsonModelBinder(ActionParameterName="student", ActionParameterType=typeof(Student)]
public ActionResult Save(Student student)
{
    // save the student 
    return View();
}

Now, I didn't try "Syper blogger"'s approach, also because I don't really want all of the devs to require to put those attributes on every action method they write. This is a huge overhead and introduces redundancy in the type definition etc.

So I aimed for a more clean approach by implementing a custom IModelBinder and by using the popular (and even more performant) Json.net library for deserializing my entities. So the result looked like

public class MyCustomModelBinder: IModelBinder
{
    private IModelBinder fallbackModelBinder;

    public MyCustomModelBinder(IModelBinder fallbackModelBinder)
    {
        this.fallbackModelBinder = fallbackModelBinder;
    }

    public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
        if (controllerContext.HttpContext.Request.HttpMethod.Equals("GET", StringComparison.InvariantCultureIgnoreCase))
        {
            return this.fallbackModelBinder.BindModel(controllerContext, bindingContext);
        }
        else
        {
            //ONLY do this for POST,PUT,DELETE requests that transmit application/json
            string bodyText;
            using (var stream = controllerContext.HttpContext.Request.InputStream)
            {
                stream.Seek(0, SeekOrigin.Begin);
                using (var reader = new StreamReader(stream))
                    bodyText = reader.ReadToEnd();
            }

            if (string.IsNullOrEmpty(bodyText))
                return (null);

            return JsonConvert.DeserializeObject(bodyText, bindingContext.ModelType);
        }
    }
}

Inside global.asax you have then to register the IModelBinder as follows:

protected void Application_Start()
{
   ...
   ModelBinders.Binders.DefaultBinder = new MyCustomModelBinder(ModelBinders.Binders.DefaultBinder);
   ...
}

Note that I'm only touching POST,PUT or DELETE requests that post Json data to my MVC3 webapp. All other requests are directly forwarded to the default model binder.

I prefer this solution of the registration of ActionFilter attributes on each action method because in this way the deserialization process is completely transparent. Let me know if any better solution comes to your mind for solving this issue.

Don't rant! Become Social and Contribute back!

noreply@blogger.com (Juri Strumpflohner) — Wed, 01 Feb 2012 06:52:00 +0000

Todays web experience has changed a lot and so has done coding as well. Everything is around being social, interacting with people through social networks, blogs or online communities. I love Open Source, mainly because you can learn so much from others' code or even just inspect it when you experience problems. Still, contributing was always a bit cumbersome in my opinion. GitHub changed that!

The more I dive into using Git, the more I enjoy the nature of a distributed VCS. Today for instance I found a very simple bug in the jQuery Validation plugin while browsing through its source. It was nothing special, but a grammar error in one of the german localization files. So, what could I have done? Well yes, just ignore it, open an issue in the according issue repository, download the source and fix it for my projects or...just fork the repo, fix it and submit a pull request!

So did I and so should you! If you're new, just get started with these steps here.

Setup your Git Tools

If you haven't yet setup your workstation to be used with Git, just follow the instructions on the official site here. There is a very nice step by step explanation with screenshots and everything you'd need to have a smooth setup experience.

Fork the Repo

Go and fork the repository where you found the bug. In my case it was the one of jQuery Validation. Again, if you don't have any experience in that, just follow the guide.

Get your repo and fix the bug

Get the source of your (just forked) GitHub repository. In my case it was something like

git clone git@github.com:juristr/jquery-validation

Then just fix the bug, commit the changes and push them back to your repo.

git commit -a -m "Fixed a grammar error in the german localization"
git push origin master

Send a Pull Request

The last step is to send a pull request to the upstream repository, namely the original repo (jQuery-validation) from which we created the fork before. Again, here's the doc.

The Result

A nice thanks from the author and your bugfix has been pulled into the master branch.

Love it!

Eclipse: Importing existing project: "Invalid project description"

noreply@blogger.com (Juri Strumpflohner) — Mon, 23 Jan 2012 07:50:00 +0000

Monday morning, 07:30 AM. Me, starting the computer after the weekend, executing a git pull from my repository to fetch the latest src. Then I opened my freshly installed Eclipse JavaScript version followed by a nice "Import existing project" (I pushed the project on my Mac previously) on the just fetched git repository. Fail.

Invalid project description

Damn. My first thought was a potential incompatibility, given that the project was created on my Mac previously, and I just tried to import it on Win7.
So if you should encounter a similar problem try the following. Assume you pulled the repository into C:\gitrepo\mygit. Then

create another directory, for instance C:\eclipsewrkspc\mygit
start Eclipse to use that directory as its workspace.
use the "Import existing project" functionality and point to the git directory
Uncheck the "copy into workspace" flag.

That approach should work, at least it did for me.

Don't Fall into the IEnumerable Trap

noreply@blogger.com (Juri Strumpflohner) — Tue, 17 Jan 2012 07:53:00 +0000

Recently I upgraded some code of our company-internal class library and observed a plausible but still tricky problem. See yourself.

In a class deep inside the class library ( ;)) there was a method which looked similar to the following:

public IEnumerable<SomeObject> GetAllValidations()
{
   foreach...
       yield return new ValidationObject(...);
}

Then, inside another method in some other class there was the following code:

public void HandleValidationErrors(IEnumerable<ValidationObject> validationObjects)
{
    IDictionary<ValidationObject, IList<ValidationErrors>> cache = new Dictionary<ValidationObject, IList<ValidationErrors>>();

    foreach(var validationObj in validationObjects)
    {
        cache.Add(validationObj, validationObj.ValidationErrors.ToList());
    }

    ActivateValidatorsAccordingToValidationErrors(validationObjects, cache);

    //snip snip: If cache not empty, some validation objects haven't been treated/found
}


public void ActivateValidatorsAccordingToValidationErrors(IEnumerable<ValidationObject> validationObjects, IDictionary<ValidationObject, IList<ValidationErrors>> cache)
{
    foreach(var valObj in validationObjects)
    {
        var validator = GetValidatorByValidationObj(valObj);
        if(validator != null)
        {
            //activate validator
            //remove ValidationObj from cache
        }
    }
}

Now guess what, line 24 gave me an exception when I wanted to access the dictionary with the validationObj as key, telling me that the key was not present. I debugged the code and the obj was present!? My first thought: did someone override the Equals()??...but that wasn't the case.

Then I immediately saw the problem when looking at the method signature. Did you get it? IEnumerable<T>. Did you hear about the "lazy-evaluation" of IEnumerables? I did, fortunately. The problem here was that when the code entered the HandleValidationErrors(...) method, passing in the IEnumerable, that latter has not been evaluated so far. And then I had the situation of a possible multiple enumeration (Resharper tells you that, so don't ignore it!). So what does that mean? When the IEnumerable was accessed 1st in line 5, the method GetAllValidations() was called, actually executing the enumeration with new instances of type ValidationObject. So far so good. Then when the loop in line 18 was executed, the same happened, returning another, new instance of a ValidationObject, basically another IEnumerable<ValidationObject> than I previously added to the cache variable. And here we are, now the exception when accessing the dictionary is quite obvious, isn't it?

Obviously this was a silly mistake and fixing it was quite easy by inserting somewhere (I did it in the first possible place to keep other devs from falling in this trap as well ;)) a line like

var theList = theValidationObjectEnumeration.ToList<ValidationObject>()

which "materializes" the list and prevents the multiple enumeration problem.

I'm writing this post because such bugs can become quite nasty to find, especially if you don't know the fact about lazy-loading of IEnumerable<T> and if the method returning the IEnumerable was written by some other dev. So watch out!

Help, Ubuntu 11.10 won't boot!!

noreply@blogger.com (Juri Strumpflohner) — Sun, 15 Jan 2012 12:25:00 +0000

Today I tried to start the new Ubuntu 11.10 from the live CD on the old desktop computer of my girlfriend. Her computer is quite slow and the old WinXP installation broken. So why not take the occasion and try Ubuntu :).

I was impressed by the new Unity interface presented in the online live Ubuntu tour. Much cleaner, more modern UI, actually there are many similarities to OSX. Anyway, I created an install CD and booted the computer from that. On the boot option I chose to first just run Ubuntu from the live CD. Everything seemed fine, but then, black screen.
As usual when you use a Linux system, ask Google. And look there, a nice forum entry with some helpful instructions (thx to the community).

Basically the problem was to change the kernel boot options from quiet splash to quiet splash nomodeset. What is this "nomodeset"?

nomodeset
The newest kernels have moved the video mode setting into the kernel. So all the programming of the hardware specific clock rates and registers on the video card happen in the kernel rather than in the X driver when the X server starts.. This makes it possible to have high resolution nice looking splash (boot) screens and flicker free transitions from boot splash to login screen. Unfortunately, on some cards this doesnt work properly and you end up with a black screen. Adding the nomodeset parameter instructs the kernel to not load video drivers and use BIOS modes instead until X is loaded.

So in order to be able to install Ubuntu I booted the system from the live CD. At startup make sure you press the down-key multiple times to enter the classic live CD menu with the options for either "just run" the system, install it or perform some memory and disk checks. At the same time, when pressing F6, there is the possibility to check the "nomodeset" boot option. Then try to run the system, it should work.

Then after having installed Ubuntu you have to do a restart. Again, press the down-key or End key to enter the startup options. Select the desired one (not recovery) and press "e" to edit the boot option as follows:

linux /boot/vmlinuz-....generic root=UUID=... ro quite splash nomodeset

Then press F10 and the system should boot.

So once you've booted the installed version you need to permanently configure the boot mode. The best way is to open a terminal window and type
sudo gedit /etc/default/grub
and edit the GRUB_CMDLINE_LINUX_DEFAULT as follows:

GRUB_DEFAULT=0
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash nomodeset"

Save the file and execute a sudo upgrade-grub. Then your computer should boot normally next time. Here's a link I found quite useful of some hints to perform after installing Ubuntu: http://www.techdrivein.com/2011/10/15-things-i-did-after-installing-new.html.

2011 Retrospective and a New Look

noreply@blogger.com (Juri Strumpflohner) — Wed, 04 Jan 2012 23:35:00 +0000

I know it's a bit late for a 2011 year recap, but I didn't manage to write one earlier. Actually, I just noted that I didn't publish one last year at all. Anyway, here just a couple of lines to 2011, the new look of this blog and maybe some outlook to 2012?

Year 2011 - A Retrospective

2011 was a very successful and interesting year. In March I finally concluded my university studies. It was an interesting, but at the same time very effortful period. After that I returned to work full-time with lots of interesting new challenges to face. Unfortunately my blog didn't (yet) reflect that much about these changes.
Beside computer science related topics I managed to enter the Italian National team of Yoseikan Budo (my club) and successfully concluded the exams for the 2. Dan Yoseikan Budo.
And last but not least, with the start of 2012 I moved in together with my girlfriend in our first common flat.

A Facelift to this Blog

Yep, once again I decided to give this blog a small facelift. The major changes consist in making the entry page more attractive, while the detail post pages remained mostly the same. The entry page now consists in small snippets of the 6 most recent posts with each posts having a small initial intro part describing its content.
Basically, the main objective was to just visualize only the most common and most important information while still giving the blog an attractive "face". Now, obviously I'm not a designer, I'm a software dev. But still I like to play around with CSS as IMHO the design of a web page/application is a major important part. Making such changes to my blog is always again a good learning lesson. But I'm open for suggestions and improvements.
Note that there are still some fine-tuning improvements coming over the following weeks as I didn't yet manage to include them right now.

And for 2012?

More blogging, more about .Net, more Android development, and finally more about web development especially about JavaScript. Let's see whether I manage it :). And obviously I'm looking forward for a year recap 2012 ;).
So I wish you all a good start in 2012 and much success.

Writing IoC Supported Integration Tests using AutoFac

noreply@blogger.com (Juri Strumpflohner) — Mon, 12 Dec 2011 13:39:00 +0000

Using a dependency injection framework can greatly facilitate your code's testability in that you don't have any "glue" code for managing a classes' dependency that needs to be mocked (if even possible) when writing unit tests. But what about when writing integration tests? In such case you'd probably want to use your IoC container's configuration for resolving types in order to also verify the proper integration of your components, frankly your dependency injection configuration, right?

With AutoFac it is actually quite simple. What your integration test needs to do is to himself create the ContainerBuilder() and accordingly register the dependencies. What you should do is the following. Assume you have a Visual Studio project that encapsulates your business logic called "BusinessLogic". Then the best strategy is to create a so-called Autofac module per project (and hence dll) to configure the dependencies within that specific project. This is done by extending the abstract class Autofac.Module like

public class BusinessLogicModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        //register other modules/dependencies here
    }
}

When you now want to write a test for the BusinessLogic project, you might create a BusinessLogic.IntegrationTests project, adding the project under test as a reference.
A possible approach to this could be the following: create ageneric class for instantiating the Autofac IoC container with the BusinessLogicModule created before. Let's call this class "IoCSupportedTest":

using Autofac;
using Autofac.Core;

namespace BusinessLogic.IntegrationTest.Utils
{
    public class IoCSupportedTest<TModule> where TModule : IModule, new()
    {
        private IContainer container;

        public IoCSupportedTest()
        {
            var builder = new ContainerBuilder();

            builder.RegisterModule(new TModule());

            container = builder.Build();
        }

        protected TEntity Resolve<TEntity>()
        {
            return container.Resolve<TEntity>();
        }

        protected void ShutdownIoC()
        {
            container.Dispose();
        }
    }
}

A specific test case might then look as follows:

[TestClass]
public class UserRepositoryTest : IoCSupportedTest<BusinessLogicModule>
{
    private IUserRepository userRepo;

    [TestInitialize]
    public void Setup()
    {
        this.userRepo = Resolve<IUserRepository>();
    }

    [TestCleanup]
    public void TearDown()
    {
        userRepo = null;
        ShutdownIoC();
    }

    //the tests
}

Exploring JavaScript: Scope Pollution when instantiating JavaScript Objects

noreply@blogger.com (Juri Strumpflohner) — Wed, 07 Dec 2011 10:15:00 +0000

John Resig has written a very interesting article (I'm not able to find just now) on how the current scope might get polluted if you're accidentally invoking a function intended as an object constructor function without using the "new" keyword in front. Here's a simple example that illustrates the issue.

Basically consider you have the following, extremely simple code:

var Person = function(first, second){
   this.name = first + " " + second;
};

//using it somewhere
var name = "Juri";
var aPerson = new Person("Peter", "Oberhofer"); //invoking the constructor function

document.write(name);

Now as expected you'd assume "Juri" to be printed as you don't do anything else than printing the current variable name.

Now what happens if you forget to use the "new" keyword like

var name="Juri";
var aPerson = Person("Peter", "Oberhofer"); //attention, no "new" keyword

document.write(name);

What would be the result? Can you guess it? It would be: Peter Oberhofer. Strange, right? The problem is that given the fact you didn't specify the "new" keyword the function Person wrote on the global namespace when executing this.name = .... The declaration of var name = "Juri" is in this case on the global namespace as well, hence without specifying the new keyword you overwrite the previous declaration, resulting in Peter Oberhofer to be printed out.

You can check out a live sample here: http://jsbin.com/ozawep/4/edit#javascript,live.

Saying Goodbye to University

noreply@blogger.com (Juri Strumpflohner) — Tue, 06 Dec 2011 21:45:00 +0000

After my thesis presentation in march this year, my university career now ended officially with the degree ceremony last saturday. I remember when I first inscribed myself about 5 years ago, at the Free University of Bolzano at the faculty of computer science. The faculty (same as the university itself) is quite young. It actually celebrated its 10 year birthday a couple of days ago. And this was reflected also on the number of students, 5 years ago, when I first entered the Analysis class with about 70 people in total. Nothing compared to the really big universities. And after the 1st semester the number even diminished until, about a year later, we were a small, constant group of about 20 to 30 people in total.

Three years later I successfully concluded the Bachelor in Applied Computer Science and decided to start working. I was interested in applying the learned stuff and collect some experiences. But still, there was always the desire to continue and so, after working full-time for a year I was given the opportunity by my employer to switch to part time and to inscribe in the Master of Computer Science..always at the FUB. It was though, really tough. When you sit at the university for studying in the morning and then in the afternoon you go at work, doing your job there, then, in the evening, you need to catch up with what your study mates did while you were at work. Thats challenging and most importantly, you need to be well organized. Nevertheless, I never neglected my girlfriend or my hobbies and thats a major important thing. This is what keeps your head above water ;).

I did it!!

Now, about 3 years later I'm here, just concluded my MSc studies getting 110/110 points (which I'd never been imagined) and having a good work place offering some interesting challenges.
Looking back, I would always again inscribe me at the Free University of Bolzano if I'd have to. A lot of people are somehow often looking at the university in a devaluating manner, mainly given its low number of students compared to other, more established universities. But that's not a disadvantage, differently, its an advantage in my eyes as you have direct contact to the professors which gives you the unique possibility to dive into interesting discussions. And the number of students is growing from year to year. Another major important fact is the internationality of the university in terms of its language model. Although being in a region where there are nearly just italian and german native speakers, the official teaching language of the computer science faculty is English. Even if this might sound pretty irrelevant, it is definitely not. English is the computer science language and it is so extremely useful in your professional career as I just experienced recently when we had a phone conference with a guy in America, reviewing parts of our code base.

Large-scale JavaScript Application Architecture

noreply@blogger.com (Juri Strumpflohner) — Mon, 21 Nov 2011 13:03:00 +0000

JavaScript programming has evolved a lot over the past years and has somehow revolutionized the way you develop on the web. While many initially just used it as a scripting language to quickly hack in some dynamic behavior into traditional websites, it starts now to be used much more like a fully capable programming language (mainly also due to many emerging JavaScript libraries and more capable browsers).

Despite this, the key to successful JavaScript development - as I've already written in a prior post and which you might have been able to read between the lines of some other ones - is structure. Without structure you're lost.., your code gets messy, a maintenance nightmare, uncontrollable, rigid ... scripting code basically. You might not take care about all this in small projects, but it becomes crucial as your project grows and gets rather big.
Take a look at the following presentation by Addy Osmani about Large-scale JavaScript Application Architecture which in my opinion nicely presents the major important points.

Some Usability Thoughts for the Weekend...

noreply@blogger.com (Juri Strumpflohner) — Fri, 18 Nov 2011 11:16:00 +0000

A couple of days ago I got the order to write a very simple program that would take a bunch of XML input files with the task to elaborate them in terms of grouping them according to some identifier and then to output the result (grouped per directory) in a more user friendly and readable way. While the prog is stupidly simple there are still some potential pitfall one might not realize immediately.

The objective was to give the tool to one of our customers in order to facilitate their work, hence: pay attention to usability factors.
I started with a simple GUI:

So far, nothing special. There is a source folder textbox and a destination folder. They're self-explanatory I guess. What the program should do (for comfortability reasons) is to create the destination folder if it doesn't exist and if it exists already, delete all its content, as it might originate from a previous elaboration.

A naive approach would be to do

if(!Directory.Exists(destinationDir))
{
   Directory.CreateDirectory(destinationDir);
}
else
{
   //delete all files and directories in destinationDir
}

But attention! What might a "dummy" user do what an "expert" user might not? Probably enter something like this:
Source: C:\sourceFileDirectory
Destination: C:\sourceFileDirectory
Bad: You delete all of the source files.

Or even worse:
Source: C:\sourceFileDirectory
Destination: C:\
Bad: You wipe his C drive :D.

These are exactly the problems that are often overlooked (as they might seem obvious) and which then cause enormous damage. Therefore a possible solution might be..

if(!Directory.Exists(destinationDir))
{
   Directory.CreateDirectory(destinationDir);
}
else
{
   //create an output directory inside the specified 
   destinationDir = Path.Combine(destinationDir, "Out");

   if(!Directory.Exists(destinationDir))
   {
      //create it
   }
   else
   {
      //Ask the user about wiping the content of the output directory
      //Do it if confirmed
   }
}

Have a nice weekend :).

Use The "var" Keyword to Have More Maintainable Tests!?

noreply@blogger.com (Juri Strumpflohner) — Fri, 18 Nov 2011 07:32:00 +0000

I have to admit that initially when the "var" keyword has been introduced in C# I was quite precautious in using it. It does reduce code readability, I thought. In the end I'd say it's pretty much a matter of style and preferences, but not only, it even might help you in avoiding to break your code when you make changes, thus leading to a more maintainable code base.

I recently had the following scenario in a lot of tests where I verified the correct validation of my entities

public void TestSomething()
{
   //Arrange
   ...

   //Act
   IList<ValidationError> result = validationProvider.Validate(entity);

   //Assert
   Assert.AreEqual(3, result.Count(), "There should be 3 validation errors");
}

However, with the new changes to our architecture I'm currently working on, I try to adapt the validation to the one proposed by ASP.net MVC and Entity Framework, still allowing to write validation rules in the same way we were accustomed so far. This led to a couple of breaking changes however, as I took the opportunity to make some improvements. As a result the return type of the validation adapter wasn't an IList any more, but instead IEnumerable<ValidationResult>. Note the generic type of the list changed as well. As a consequence the tests didn't compile any more and I had to manually fix them all (although it was just a matter of search&replace ;)).

Instead, if I had written those tests by not explicitly defining the collection type but rather to just declare them using the var keyword, my tests would have continued to work without any problems.

public void TestSomething()
{
   //Arrange
   ...

   //Act
   var result = validationProvider.Validate(entity);
   ...
}