Some stuff about Web and .NET development
RSS icon Email icon Home icon
  • Thanks Balsamiq !

    Posted on April 28th, 2009 Thibaut 2 comments

    Blog mockup


  • Balsamiq Mockups

    Posted on April 27th, 2009 Thibaut No comments


    Balsamiq Mockups is a great tool that enables you to draw prototypes of applications. This soft features about 80 controls - ranging from dropdowns to cover flows - that you can drag/drop, resize, customize, etc in order to make your prototype the more precise as possible. This is again a tool that we’ve used at work to make some prototypes about the future version of our application and we were very happy with the results, so I strongly recommend this tool.

    Unfortunately, I don’t own myself a license for this tool yet, but I’ve heard that Balsamiq was kind enough to offer some in exchange of a blog post, so I’m trying my luck ;)

    See you soon !


  • What’s wrong with innerHTML ?

    Posted on April 24th, 2009 Thibaut 1 comment

    Every javascript developer knows innerHTML, that famous DOM property that allows you to set or get the HTML markup string of an element. It’s easy, it’s fast but it also kinda sucks. Here’s why :

    • It’s not a standard (it was originally introduced by Microsoft some time ago)
    • innerHTML is only a string with no structure. On the contrary, the DOM is a structured tree that allows to manipulate elements in a way cleaner manner. And you can put plenty of errors into that string without even getting a single warning from the Javascript
    • Maintenance is way much complicated if you have to dig into a complex HTML string than just inserting your line between the right CreateElement() methods of the DOM

    // Note how it’s easy with innerHTML to introduce errors

    // In this case, the div tag is not properly closed

    document.body.innerHTML = “<div>Some text</div”;


    // Now with the DOM, in a cleaner and more secure way

    var elt = document.createElement(“div”);

    var txt = document.createTextNode(“Some text”);



    But… innerHTML isn’t completely bad though. In fact, it’s way faster than the DOM and is pretty well supported by browsers. So what should you do then ? There are loads of discussions on that topic on the web. In my opinion, you should always strive to respect the standards, which are primordial when you’re working for the web, but this must not slow down productivity either (by making some libraries or helpers for example). Now the big question : What are my alternatives to working with innerHTML ? This very interesting article will perfectly answer to that.


  • Writing a clean CSS

    Posted on April 22nd, 2009 Thibaut 3 comments

    As I was surfing on LinkedIn, I came across an interesting discussion named Writing a clean CSS. And one interesting thing that caught my attention was the following thing : breaking down a CSS file into areas such as these ones :

    • Defaults
    • Structure
    • Links and navigation
    • Fonts
    • Images
    • Tables
    • Forms

    Indeed, this kind of structure, when applied to each CSS file of your project, can be a great save of time in development and maintenance process. I would highly recommend to write this down as a code snippet in order to get  a consistent scaffolding for your CSS’s at light speed. Getting a header and footer sections can also be very valuable in order to reach immediately these areas when needed. Another thing I’d suggest from my past experience in developing webistes at Emakina, where you often have to cope with CSS’s of hundreds of lines, is to comment the instructions that are not always clear at first sight. Typically, I’m talking about browser-specific code to ensure compatibility and thus commenting the reason of their existence in your file, or long selectors such as the one below :

    /* Sets the picture style for third-level alternating items of the menu */

    div#left ul li ul li ul li span.alt a img {

        border : solid yellow 1px;


    Also notice the genericity of the comment. It could have been Sets the border of the picture to yellow but you’ll then become strongly bound to the current style, and suppose you’ll change it to red later, then your comment would’ve become unrelevant.

    Don’t hesitate to comment on that and/or to suggest your best practices :)


  • Gliffy

    Posted on April 19th, 2009 Thibaut 2 comments

    Gliffy is an online diagramming tool that enables you to create professional-looking flowcharts, diagrams, floor plans, technical drawings, and more. We used it recently at work to make some database diagrams and as I found this tool nice, I thought it would be interesting to share some information about that here. FYI, a limited free version is available but you’ll have to pay in order to get all the features enabled. But as the soft seems very promising, I think it’s worth it !


  • Visug and Besug groups on LinkedIn

    Posted on April 6th, 2009 Thibaut No comments

    Visug group   

    In a previous post, I talked about the Visug, the belgian Visual Studio user group that organizes very interesting meetings. And as a participant, I thought it could be interesting to create the Visug group on LinkedIn to connect its members and get more easily in touch. Feel free to join the group here !

    And there is also a brand new user group called Besug (BElgian Silverlight User Group) that organizes sessions on everything about Silverlight. I’ve already registered for this group and I’ll assist to future sessions because as a web developer, I’m very interested in Silverlight. You can join this group here.

    See you there ;)


  • Do not use List<T> in public signatures

    Posted on April 5th, 2009 Thibaut No comments

    The List<T> class is the generic equivalent of the ArrayList class. It implements the IList<T> generic interface using an array whose size is dynamically increased as required and can be useful in many contexts. But you should avoid using it in public signatures. Why is it so ?

    • The List<T> has too many members that makes it too heavy for many scenarios. Indeed, you might not want to return a List<T> collection with all its richness in all situations. According to some people, it’s even a violation of the Single Responsibility Principle
    • While the List<T> class is not unsealed, it’s not specifically designed to be extended. Indeed, the class has no protected and virtual methods to allow beheviour altering through inheritance.

    What should you use then ? It’s recommended that you use IList<T> or derived interfaces in public signatures.


  • Antipatterns

    Posted on April 5th, 2009 Thibaut No comments

    While reading Architecting Applications for the Enterprise, a book I’ve bought at the latest Techdays edition, I came accross an interesting notion : antipatterns. As the name suggests, an antipattern is just the contrary of a design pattern, which means that it’s something that leads you from a problem to a bad solution. Just a bad idea actually, but as you can find books and many other resources about design patterns - because they’re very useful and valuable - listing antipatterns can also be very interesting.

    You will find a antipatterns catalog here. Indeed, design patterns became a hot trend in the past years and many developers tended to use them just for the sake of using a pattern. But making your problem match a pattern will make you walk down the wrong way. Instead, you use a pattern because it can solve your current problem and if there is none, then it seems you’ve just found the right solution ;)