Alexander Beletsky's Development Blog

The Limit of Keystrokes

2012-05-26T15:03:00.000+03:00

Some time ago I've posted an article called How to be better developer or 3 accounts rule where I shared my vision on importance of having some accounts if you care about professionalism and mastery. The basic idea there is you have to produce a lot, you have to write a lot. You have to write code, write blog posts and help people on forums.

If you have seen one of the latest Scott Hanselman's Productivity Tips video, you probably heard nice metaphor about the "Limit of Keystrokes". It sounds really funny, Scott saying - "everybody is having limited count of keystokes, if you reach you count - you dead". That means, we have to think on each keystroke we do with much care.

And the most efficient usage of keystrokes is for learning. Reading is very important, but nowadays there are so many information that you just not able to consume everything. That's why recently I've unsubscribed a lot of RSS channels in my Google Reader, I think I will filter the Twitter as well. Instead, I try to read as few things as possible. Not only read, but try them on practice. Just write some small code to try the idea, pattern, approach of framework. Turning the theory in practice is something that gives me much fun and satisfaction.

Yesterday, we were doing Coding Dojo with good friend of mine @skalinets on Agile Base Camp conference. Instead of going my default language (which is C# for now) I paired the PHP guy. We were doing String Calculator kata in PHP. It was so great! First of all, I amazed how much PHP improved since the last time I looked on it (about 10 years ago), second is that I used my keystrokes to learn something new.

Writing the code for fun and learning has a huge value. This is definitely good investment of the keystrokes.

Github for Windows - Yay!

2012-05-21T23:44:00.001+03:00

For quite long time Windows users of github had a huge envy towards Github for Mac - the application that makes work with github based repositories as simple as possible. A lot of people, especially ones who are not familiar with Git, experiencing some issues with github initially. No surprise, extensive command-line, SSH, public/private keys - might sound scary for GUI addicted persons.

December 2011, Phil Haack joined github.. so, the world hold the breath, to see what actually will be done by Phil and team to improve overall Github experience on Windows. And the day has come! Today Github:Windows is officially shipped.

What's the point?

As well as Mac users, Windows users are also much got used to UI. For long time, if you want to deal with Git on windows, you have to go and install msysgit. It's a great product and works great actually, but you have to spend some time of learning of Git to do very basics operations. Moreover, if you hadn't had any experience with distributed version control systems - you'll be to much confused by new words like: pull, push, clone, fork, cherry-pick and so on. Github for Windows is about to fix that.

Go ahead and install it

Installation is very easy. Just click the download link, to get web setup file. Two things are gonna installed on you machine: Github client itself and Git shell - the powershell command line for git.

Github for Windows client

At the first run it will do some configuration stuff. It will ask you for github credentials.

As you logged on, it will show you some basic account information.

It will also add new public SSH key your account. That was a little unexpected as I received email notification for github about that. The information that it's gonna do that, probably should be mentioned during setup.

Then it tries to locate all repositories. It scans the home folder, but I don't keeping repositories there (just some temp copies), so I unselected everything.

As I tried to go straight and create new repository the application crashed. Oppps.. It reproduced several times, but after gone. Anyway, I contacted support@github.com with detailed steps and info.

Finally, after I changed the default folder and wait till it's completed scanned (that took about 3 mins on my machine), I got client working.

Even if I'm not huge fan of METRO style - I was really pleased with UI. It looks very nice, application works fast and responsive. It takes almost no effort to overview application features.. everything is very intuitive.

It's of course not the perfect. I tried to do some commits, that seems to be fine.. but sync of the repo failed. It also fails to switch the branches in 95% cases.

Git Shell for command line

Next good addition is Git Shell, powered by PowerShell (nice!). It utilizes famous posh-git project. The most useful features for me now: 'Tab' support that provides suggestion for the command and 'Stats' that are shown at command prompt, showing current repository state. There are probably a lot of other cool things there, that I haven't discovered yet.

If you are fan of Bash, or pure Cmd.. or custom stuff (as Console 2) it very easy to change that, right in application configuration.

Conclusions

Even if it's just first release, it's very solid and a lot of features already there. Issues exist, but I hope it will be cleared out soon.

What make me a little wonder, that the project is not open sourced? I hope it's just the question of time, I'm pretty sure that a lot of people are waiting to see what's inside and submit some pull requests.

Will I personally use that product? Probably, not. I've spent too many time in Command-line of my favorite Far Manager, that UI is more noise that help. What I will use is Git Shell, thought. I've heard a lot about posh-git, now it's time to try.

But for all people, who are just starting using Github on Window - Github:Windows would be my first recommendation.

CS101 Building a Search Engine: Week 4

2012-05-20T14:50:00.000+03:00

Disclaimer: this blog post expresses some impressions and details of Udacity CS101 "Building a Search Engine" online course. If you are either currently participating it or plan to do so in nearest future, this blog post could be a spoiler. Even though, I'm trying to make it generic as possible and do not spoil important things.

I've got completed Unit 4 of course during this week. It's getting more and more interesting and the crawler we building there getting more complicated.

This week we got through the basic data structures, mainly based on lists. The most interesting thing was an index data structure, thought. We've built the simple page indexer. Now the result of crawling is not simply the list of crawled links, but instead is index that keeps track of content (as word) and the URL where the word is mention. If some of you don't know what the index is, the simplest explanation is get just to open any technical book. At the end of the book you will see "Index" section. By looking for information you have to option. Either go from one page to another, finding keyword appearance.. or go to index and see exact pages, where this keyword is mentioned. Indices are essential for quick search of data.

The index that my crawler produce, crawling the test page is:

[['This', ['http://www.udacity.com/cs101x/index.html']], 
   ['is', ['http://www.udacity.com/cs101x/index.html']], 
   ['a', ['http://www.udacity.com/cs101x/index.html']], 
   ['test', ['http://www.udacity.com/cs101x/index.html']], 
   ['page', ['http://www.udacity.com/cs101x/index.html']], 
   ['for', ['http://www.udacity.com/cs101x/index.html']], 
   ['learning', ['http://www.udacity.com/cs101x/index.html']], 
   ['to', ['http://www.udacity.com/cs101x/index.html', 'http://www.udacity.com/cs101x/crawling.html']], 
   ['crawl!', ['http://www.udacity.com/cs101x/index.html']]
   # ...

I went a little above the given task and improved the crawler with "clean-up html tags" functionality. So, I get the body part of document, strip out all HTML tags and then index the content. The latest version of crawler is in this gist.

We also looked on some Internet fundamentals as: bandwidth, latency, traceroutes and protocols.

I haven't yet started any project on python except the crawler one. With implementing the of more complex applications I start to feel the lack of IDE with debugger. I currently use Sublime Text 2 + print statement as my IDE and debugger tool. It might be time to look for something better.

Everything is going fine so far, except the fact I'm being late for one week. The final exam is going to be posted at 27th of May and it will take one week to have a change to pass it. So, I've got a goal to complete 2 units through this week. The half of course is done!

A year with Git

2012-05-20T13:43:00.000+03:00

It's almost a year ago, I've posted the article How to start using Git in SVN-based organization. It has been viewed more than 3,000 times on my blog and more than 9,000 times on re-post by DZONE.

Time has passed and some of you might be interesting, what happed next? A lot, actually.

I think we followed "Baby steps to.." strategy of Git adoption. Our baby steps to Git, were small, accurate and quite long. But at the end of the day, I'm happy to say - we are pure Git organization now. Moreover, some of our projects are hosted as public and private repositories under the e-conomic organization github account.

Retrospective

So, let's make a kind of retrospective seeing what things were happening.

Git-SVN mode. As described in original article, the best way to try Git inside the organization is go to Git-SVN mode. It will allow to use SVN as primary repo, but allow Git features like local branching, cool merging, stashes and other stuff described here.
People awareness. Started by just few developers the information about the Git had spread along mates in our department. Some were very enthusiastic about that, some not. But anyway, it got attention of our many people including our CTO. The greatest thing is that initiative has not been cancelled, instead we start to think of some kind of plan that might bring us into pure Git world.
Planning. Our plan including different evaluations, choosing between Git or HG, local or cloud hosting, Centralized or De-centralized mode etc. During this planning sessions we also identified some infrastructure dependencies that blocked switch to Git. We have so called "Language System" the application helping our copyrighters and translators to change the content of app. It's been creating assuming that SVN used, doing checkouts and commits where. Another thing is that our deployment procedure happened to be SVN dependent. Obviously, it have to be changed to work with Git. But the most priority had "Education" task. Everybody should be able to work with Git.
Execution. Planning is easy, execution is hard. We did initial education as a series of meetings were the basics are described. Fortunately, almost as teams contained the git-aware person who were initial knowledge keeper. Some important details being moved to company's Wiki. The problems we start to have local infrastructure setup. Being Windows organization we tried to setup primary repository and server on Windows box. Keeping that short, I just say - don't do that. It's not trivial at all, to configure Git server there, setup the accounts and permissions and make it work with TeamCity. We tried different scenarios of Git hosting on IIS, including Bonobo-Git-Server or Git-Dot but all had it's own limitations, blocking us of full-feature Git usage.
Trying github. In parallel, one team that was starting out new project and was quite independent tried to host sources in cloud. Github is obvious choice here. I think, that was a great experience and this project is still hosted on github. We tried, so called "organization" mode. It ideally fits small software development shops. Easy start, easy go.
Linux local server. Failed to run it properly on Windows we had to switch to Linux box. It's being deployed as virtual box, that is more than enough for Git server. That solved a lot of infrastructural issues, including authentications & permissions as well as CI problems. As I can see the effort to setup it was not so big (if compare to effort spend to make the same on Windows, it would be closer to 0). Setup once, it just start to work.
Mirroring repositories. The setup of local central server was the first great milestone. Even if all the developers might start to use it instead of SVN, the infrastructural problems that I mentioned in #3 were not yet solved. So, we did a partial decision. The developers are switching to Git repository, but the deployments and language works are still done on SVN repository. So it's not so frequent operations, it's possible to synchronize the Git and SVN between each other. It means, all new code started to appear in Git, but once a week (or often) all changes set are being pushed to SVN. This is of course an overhead and required some manual work.. But it was only one way for us.
Fixing the dependencies. It took some time while everybody got comfortable with Git. Our Wiki has extended with some policies of working with Git. We mainly follow "A successful Git branching model" keeping the feature in local branches, having remote branches for code review etc. After our deployment dependency has been fixed, we were able to push the code to production very fast. I think it's almost a year passed to now clearly understand benefit of Git not just theoretically, but practically. And that was amazing experience, as so for me.
Pure git world. After the last dependency has been fixed, we happily entered the "Pure Git Environment" world. The SVN server has been stopped. All developers, DevOps and copyrighters are Git users now.

It took a while...

Yeah, it took awhile but we never had this migration as top priority item in our backlog. The process were long and smooth, allowing us to do our primary job of bringing value to product, but the same time improving the internal infrastructure.

Not being hurry is also good option, sometimes. The whole transition took a lot of efforts of different person along the way. I say thank you, guys - for making this happening.

What's next?

The things are stabilized now. We are on one solid solution, working very nice. As I said, we have both local and github environments. If I pretend to be a medium and see the future, I would say we go to "pure Github" environment from here. Sure, now this transaction having it's own dependencies. But let's see what's happen during next year.

CS101 Building a Search Engine: Week 3

2012-05-07T12:58:00.000+03:00

Yesterday, I've concluded Unit 3 of CS101 Building Search Engine class. I had a little lag, since I've been to little vacation at the beginning of previous week, so got a chance to get back to class only Thursday. So, I still have one homework task in my to-do list.

It's been an interesting unit, through it's still very basic one. I'm little more confident with Python, getting powered by knowledge of collections, indexes etc. Again, I'm really pleased with language simplicity. Just few code snippets I like,

# creates generic list
        some_list = []
        
        # add something inside
        some_list.append(1)
        some_list.append('z')
        some_list.append([3,2,1])
        
        # iterate by for loop
        for e in some_list:
            pass
            
        # or with while
        while some_list:
            e = some_list.pop()
        
        # get index of element
        index = some_list.index(1)

I also started to familiarize with functional style of Python programming. You can find some good inputs here. Everything look very interesting so far.

This week we moved further with "real" implementation of web crawler. Instead of going by the set of quizzes I went my own path and created my implementation of simple crawler. So, what it does currently is go from 'seed' page and collect all links it's able to find on target pages and related pages. I went a little far, since I made it run on real web requests, instead of test data that current unit supposes. If you are interested code could be found here.

Still I pretend as CS101 student trying to apply only knowledge I got through latest weeks. It's great exercise I believe, showing some gaps in my education or concept understanding.

Homework was interesting as well. Anna Patterson was a starring guest for homework session. Together with Anna we tried to improve crawler with some real life requirements, like max_pages and max_depth parameter to prevent crawler to stay in indefinite loop. Anna is great expert in this field, so for each homework task I highly recommend to check the answer, a lot of interesting details there.

CS101 Building a Search Engine: Week 2

2012-04-28T11:31:00.000+03:00

This week I've concluded Unit 2 of CS101 Building Search Engine class. As a previous one it was very basic. We did went thought programming fundamentals on if statements, while loops, conditions and boolean operations. In contrast to Unit 1, I haven't got any really new information for me. All the information given very nicely, preparing listener to do some more serious stuff.

I think I started to get used to Python a little bit. Unfortunately I do not practice it much now, so I have to find simple project that I could accomplish in Python, besides the search engine. As always doing code katas is very nice for introduction to any new language, so I can do that.

Homework was simple enough, but again as last time I got one problem that made me think some extra time. This is "median search" issue. Say, you are given 3 numbers - (1,2,3). Median is the one between bigger and smaller number, in this case it's "2". In (9,3,6) it's "6" and in (7,8,7) it's "7". As a previous time I started with something I don't suppose to know, like lists and sorting. Solving this problem just with knowledge I got so far more problematic. So, I spent some time on that.. and was really happy than I found simple and nice solution for that. You should try to solve that, pretending you know only procedures and conditional operations.

Now, I'm looking forward for Unit 3. It's still basic, but there we suppose to create some simple crawler. I hope it will be fun!

JSON Model Binding to IDictionary<> is Broken

2012-04-26T09:39:00.000+03:00

Yesterday, I've been creating small web service based on existing ASP.NET MVC infrastructure. The task was really simple. Web service itself should be just a proxy for existing internal API. The API method takes a Dictionary that contains some fields. So, I've created a data model like that.

public class Notification
{
 public int Id { get; set; }
 public string Recipient { get; set; }
 public IDictionary<string, string> Fields { get; set; }
}

and simple HttpPost handler, like

[HttpPost]
public ActionResult Send(string token, Notification notification)
{
    // ...
}

the payload posted to method is:

{"id":32,"recipient":"a@a.com","fields": { "EMAIL": "a@a.com"} }

I've tried to test the method, but the Fields property of model was always null. First I thought I got a problem somewhere in JSON payload, but after sometime I saw that everything is correct.

Google showed I'm not alone, so the issue been raised on SO. Darin Dimitrov responded that this is a bug of JsonValueProviderFactory. In the same time, some comments below contained the link for a bug reported, that was already stated as Fixed.

I forgot to mention that I did that stuff on ASP.NET MVC 2. I decided to try that on ASP.NET MVC 3, since I got the sources and if it works I can try to backport the fix into our MVC 2 infrastructure.

With my great disappointment it fails in exactly same way for ASP.NET MVC 3. That's not funny anymore. I blamed JavaScriptSerializer, JSON serializer that used inside the JsonValueProviderFactory that it simply not able to handle Dictionaries right. I knew that ASP.NET Web API is using Newtonsoft JSON.NET framework, which is really powerful for serialization/deserialization of JSON.

So, I run VS 2011 and create test ApiController that receives the model with IDictionary inside. What do you think happen? Ok, the model is no longer null, but it contains Dictionary with count of elements equals to zero. Fail.

public void Post(Notification notification)
{
    // ...
}

I re-raised issue again, now on ASP.NET Web Stack site on Codeplex. I also tried to quickly write the unit test that show the existence of problem, but it's not that easy to do that, so it requires some time. Hope I can do that later.

CS101 Building a Search Engine: Week 1

2012-04-21T20:54:00.000+03:00

CS101 is fundamental course that supposes you have no background in programming at all. That's why all lectures was very-very basic and sometimes I felt really bored. If you fell the same, that's probably ok, since the most interesting stuff is about to start from Unit 3.

In the same time, for guys who has no programming skill's that might be even a little tough. To be honest, I had really tough moment during my first homework, that should not be a problem for professional programmer, but I'll describe it later.

Unit 1: Basics, Python, Numbers and Strings

What I understood from my entire career is that: backing to basics is always great. The years of enterprise development makes you strong in technologies and frameworks, but I managed to lost almost everything I got during my university days. Restoring that knowledge is very good brain exercise, constant repetition of basic is the way to mastery.

So, even that simple unit gave me a lot of things to remember, plus I learned some elementary of Python language.

Backus Naur Form

What was really interesting to me during Unit 1 is so called Backus-Naur Form, for describing the computer language grammar. This is a method of formalizing any (probably) computer language syntaxes. It has been invented by John Backus American scientist, how is famous as creator of FORTRAN and ALGOL computer languages, as well as his researches in functional programming.

Backus-Naur form is really simple and really powerful. It is described by the set of non-terminals and terminals. Each language expression is derived from BN form. Let's take and example,

<sentence> ::= <subject> <verb> <object>
        <subject> ::= <noun>
        <object> ::= <noun>

Here is the primitive BNF for English language. Each sentence in English should contain Subject, Verb, Object to be complete and have a meaning. Of course, BNF is not suppose to describe natural languages as English or Russian, since it much more complex.. but it works very fine with computer languages, which are strict. So, everything in brackets are so called non-terminals, it simply means that expression could not be terminated (completed) based on them. To complete we need terminals. Each non-terminal is replaced by terminal till it's done.

<sentence> ::= <subject> <verb> <object>
        <subject> ::= <noun>
        <object> ::= <noun>
        noun ::= I
        noun ::= Python
        noun ::= Cookies
        verb ::= Eat
        verb ::= Like

Now, the form is completed, so we can try to derive expression out of it. Let's try that. So, we start from the top line

<sentence> ::= <subject> <verb> <object>

Derive all non-terminals from expression

<sentence> ::= <noun> <verb> <noun>

First "noun" is still non-terminal, so we proceed. Due to form, noun could be any of three (I, Python, Cookies) - so I can pick up any.

<sentence> ::= I <verb> <noun>

"I" is the terminal, so we process next non terminal which is verb. Verb could be any of (Eat, Like). I'll take "Like".

<sentence> ::= I Like <noun>

The last non-terminal is noun again. The same three options (I, Python, Cookies). Let's pick "Python".

<sentence> ::= I Like Python

All non-terminals are replaced with terminals, that means we derieved the expression completely. Based on that simple algorithm I can derive other expressions that would be valid for that form.

<sentence> ::= I Like Cookies    
        <sentence> ::= I Like I    
        <sentence> ::= I Eat Python    
        <sentence> ::= Python Like Cookies
        <sentence> ::= Python Eat I

As you can see, some of them are completely non-sense, but still they are totally valid expressions. If you are curious, you can find BNF's for many know languages here.

Starting up Python

Start with Python programming language was one of my goals, dusted for quite long time on goals shelf. Hope that CS101 and further courses would be motivating enough to finally learn it. So, if you are like me - .NET, no Python background - don't worry, that's easy enough. Basically, all you need is Python interpreter and some text editor.

I really like Chocolatey for installing that stuff. Chocolatey is like NuGet package manager, but for software. I encourage you to try. So, instead of going to site, looking for latest version etc. I just opened my Power Shell command like and put:

cinst python

In 3 minutes, Python was on my machine.

The editor, you can pick up any you like. I prefer Sublime Text 2, it's really cool. Again, you can install it by Chocolatey.

cinst sublimetext2

After that you are almost Python developer. Just need to learn the language.

Strings, Find in strings

The rest of Unit 1, was mostly string operations in Python. And I was surprised how easy Python syntax is. First, you don't need to 'mark' varible declaration anyhow.. No types, no 'var' just the name and value.

s = "Hello World"

You can access each char inside the string just with [] operator.

s = "Hello World"
        print s[0]

It would print "H" char into console. It's not really cool, what cool is - substrings by index and negative indexes.

print s[0:5] # -> Hello
        print s[:5]  # -> Hello
        print s[6:]  # -> World
        print s[:]   # -> Hello World
        print s[-1]  # -> d
        print s[:-5] # -> Hello

The find operation is very similar to what we have in C++ and C#. It, tried to find substring in string if it's find, position returned or -1.

print s.find('World') # -> 6
        print s.find('o')  # -> 4
        print s.find('o', 5) # -> 7

The last thing in the unit was str() method, that able convert any number (integer or float) into string representation.

print str(3.14)  # -> 3.14
        print str(100)  # -> 100

That's it. Based on that knowledge I suppose to complete my homework.

Homework

Again, as whole unit - there was really simple problems. The 'real' tough guy to me was very simple problem - "Rounding numbers". So, you are given with float number and you have to return it's integer representation. If numbers fraction is greater than 0.5, it should go ceil otherwise it goes floor. Not big deal I thought to my self and start to write code..

I spend around 10 minutes to create code like that:

number_as_string = str(x)
        dot_position = number_as_string.find('.')
        if dot_position != -1:
         integer_part = int(number_as_string[0:dot_position])
         decimal_part = int(number_as_string[dot_position + 1:])
         decimal_length = len(number_as_string[dot_position + 1:]) 
         dividor = pow(10, decimal_length - 1) * 5 

         if decimal_part >= dividor :
          integer_part += 1

         print integer_part

While writing that I had a bad feeling, that I'm using something that I'm not supposed to know, actually. The code worked and I submitted the solution. I received a response, that it actually giving right answer.. but, I was asked to create solution without if, int() or round().

Believe me or not, but I really frustrated on that task. I just didn't understood how it's possible to do not use any if here, but I have a condition inside the problem. I spend additional 10 minutes, starting to think it's just impossible. It's really funny, but indeed I thought it's something strange and had a great temptation to go and check for correct answer. Fortunately, I got this this online discussion (each course has it's discussion board, where student's can share the info). It turns out I'm not alone, some professional programmers did the look like I did with if's and calls to other functions.

Finally, I just tried to concentrate and really pretend to be a person how is just listen to that material first time, using the only knowledge I got in Unit 1. And solution came up to my mind! It was sooo easy, so I felt really ashamed for the code I wrote above. It's 3 lines of code, using just str() and find() method, so simple.

That was definitely facepalm situation. But, it really encourage me to continue!

I Enrolled to Udacity 'Build Search Engine' Online Course

2012-04-17T18:55:00.000+03:00

I'm astonished how many opportunities we have now to learn and self-improve there days. One of the greatest things was announcement of online courses by Stanford. Stanford is the world class university with best professors and highest reputation. Then I first time heard that some of Stanford courses are online with videos, quizzes and materials - I thought to my self, - I would not miss the thing.

With a great support of Coursera and Udacity now we have great list of interesting courses, including programming, artificial intelligence, cryptography etc. Lead by well known specialists those courses are just price-less, nevertheless they are available for free.

I have enrolled for new course by Udacity - CS101: Building a Search Engine that has been started 16 Apr 2012, by David Evans and Sebastian Thrun. This should be interesting journey inside the web crawling, data mining, ranking etc. What is good for me it would not evolve hardcode-math and also does some good introduction into Python programming language. By the way, CS101 does not assume you know any computer language before or any special math knowledge. So, my assumptions that this course should not take hours of digging into the difference between o(n) and O(n) but rather has more practical aspects.

So, why I'm writing that?.. Millions of people are joining them, a lot of people already got successful records for several courses already. OK, let's look in eyes of truth. I enrolled for several ones already (ml-class and saas). But neither I successfully completed. Due to my business (read as laziness) I quickly went out of schedule and it was to difficult to line up again. I don't want it happen again.

I have some small goals for a next 7 weeks:

Start up learning new language
Lean something new in data mining and data processing
Improve my self learning discipline
Encourage myself for next online courses

I think CS101: Building a Search Engine is vey nice candidate, because:

As I said it should not include very complex math (that I already manage to forgot)
It has no strict deadlines for units
It is interesting enough to do not be bored in a middle (at least I hope so)

Moreover, I'll be doing a weekly blog post (Saturday) about highlighting the things I learned through week. If you are interested, please jump in since that train is still not gone. I'm sure it will be great experience.

Let's do that together!

ASP.NET Articles Mobile Application

2012-04-12T16:50:00.000+03:00

Do you like asp.net web site content? Do you enjoy reading fine selected articles about ASP.NET and related technologies? Me too, but I spent most of the reading from my iPad. And unfortunately asp.net is not that mobile friendly yet, moreover articles are just a bunch of links to developers blogs, that might not so be adapted for mobile devices as well.

So, I would like to introduce mobile application that I created to close the gap. Please welcome http://aspnetmobile.apphb.com/.

aspnet.mobile is rather simple application. Despite of many similar apps that uses RSS channel, it goes for ASP.NET portal simple external API. RSS is bad in the way that you are limited with initial content (typically up to 25 articles on channel). With aspnet.mobile you freely can access any article ever posted on ASP.NET.

It's powered by jQuery Mobile that currently provides more "iOS-look" interface. I'm happy with that currently but I plan to have native look for Android and WP7 as well, so I thinking either to change the framework or to create custom one. But it currently looks and works great on iPad.

I didn't want to just refer reader to developers blog, for the reason above. Instead, I much inspired by iOS 5.0 Safari feature called 'Reader'. A bit of googling and I found that Safari using technology called Readability. There are different ports of that technology for a different platforms: Ruby, PHP, Python, Node.js.. and I was happy to find great implementation of NReadability by Marek Stoj. Basically, it allowed me to render nice looking pages, like:

Besides of that it has a basic support of offline mode. All read articles are stored in Local Storage, so once the application offine it will provide proper behavior and propose some content.

I will be happy if you try and let me know your impression. Feel free to check sources at github.

New in ASP.NET MVC4: Razor changes

2012-04-10T21:35:00.000+03:00

Razor has been changed a little with ASP.NET MVC 4 beta. It's not a kind of radical changes, but rather improvements that make developers happier. As for me, developers happier then you need to write less code to get the same function. It reminded me a ideal device, which is part of TRIZ theory. Ideal device is a device that does not exit, but does it function. By analogy, ideal code is the code that not exist but it's function exist. Razor is not that ideal, through.. But it's "more ideal" than previous version.

No more @Url.Content

I got used to @Url.Content and used that for all CSS and JS references. Since it's to commonly used, developers decided to include it on a level of engine. Now, instead of

<script src="@Url.Content("~/Scripts/Controls.js")"></script>

You simply can write,

<script src="~/Scripts/Controls.js"></script>

If Razor detects ~/ it would created an output identical to @Url.Content. Just got rid of several bytes within view files.

Conditions

Conditions in attributes were pretty noisy. Have you ever create something like this?

<div @{if (myClass != null) { <text>class="@myClass"</text> } }>Content</div>

I had and I did not like it much. I usually ended up with creation of some simple HTML helper instead. With new Razor it a little simpler, not you can write

<div class="@myClass">Content</div>

If @myClass is null, it won't output class attribute at all. Very handy.

And a little more

This is an update section I created after this post has been twitted by Scott Guthrie and some valuable comments has been received.

Brad Wilson stated, conditions does not only support nullable types, but also booleans. Say, I have code:

<input checked="@ViewBag.Checked" type="checkbox"/>

If the @ViewBag.Checked in null or false, it will be rendered as:

<input type="checkbox"/>

Else if @ViewBag.Checked is true, it will be rendered as:

<input checked="checked" type="checkbox"/>

Erik Porter also mentioned the custom support for data-* attributes. Data attributes are little special, so even if you missing particular value you still want to have those as empty data-role = "". So, if you have code like:

<ul data-role="@ViewBag.ListRole">
</ul>

and @ViewBag.ListRole is null or false, data attribute will be eliminated. That's how it work in Beta. But for next releases data-* attributes will be treated specially, so even if value is null or false they will be rendered as empty ones.

Conclusions

I haven't noticed any more changes so far. It's great to see that Razor has not been "frozen" and still improving. I like that view engine first of all by it's simplicity. So making it even more simple would definitely make it more attractive.

Why I'm Not Using Bundling.. Yet

2012-04-04T18:32:00.000+03:00

Last time I a posted some initial info about Bundling and Minification abilities of MVC4. In this post, I describe some concerns that prevents me of using it right now. Let me remind that I'm doing review of MVC 4 beta and I hope some of those concern would not be actual at the time of release. This is only personal considerations, you might not agree with everything here.

It's contra-intuitive

Maybe the 'contra-intuitive' is not exact word that reflects my frustration. What I mean, it does not do what you might expect by default. Remember I described two methods RegisterTemplateBundles() and EnableDefaultBundles()? It was really unclear to me what they do until I looked into code. Modern frameworks tend to be as less surprise as possible, but not in case of System.Web.Optimizations.

Development and production mode

The fact it does not take into account 'Debug' and 'Release' mode is also very confusing. As same as in point above, I have a different expectations how it should behave. For 'Debug' mode it simply should do nothing - no optimization, no compression. For release mode it should do as much as possible to minify the number of HTTP request. It turns out that you have to create some code on your own to make it happen.

Bundling is bad during debugging

While you in development mode you do debug, no surprise here. Having FireBug or Chrome Development tools it's very easy to debug javascript, you can pick up any file and place breakpoint inside.

It is no so easy with bundling, cause it will package all your files in one big chunk, so you need to open and find right place there. Since the total number of line could be huge there, it's turns to be big deal.

As a workaround you have to have a copies of references, one you using on development and ones you use on production.

<!-- Development -->
<script type="text/javascript" src="~/Scripts/jquery-1.6.4.js"></script>
<script type="text/javascript" src="~/Scripts/jquery.mobile-1.0b3.js"></script>
<script type="text/javascript" src="~/Scripts/knockout-2.0.0.js"></script>
<script type="text/javascript" src="~/Scripts/underscore.js"></script>
<script type="text/javascript" src="~/Scripts/App/CacheInit.js"></script>     

<!-- Production 
<script type="text/javascript" src="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Scripts/js")"></script>
-->

It's not well ironed

Since it's very young obviously it has some problems.

Be honest, I haven't seen on my own but one of the comments in my previous post described the issue with minification of CSS files that include -ie- specific selectors. That's probably not only one issue found.

What did I expect?

To do not have only critics I try to put some constructive part in post as well. Ok, so I see it should work to meet my needs?

First of all, it should be implemented as simple HTML razor helpers. You just specify the name of bundle there, like "scripts/js" and that's it. Helper is smart enough to understand what is active environment at the moment. In case of 'Debug' it expanded to a bunch of script references or links, for JS and CSS respectively. In 'Release' mode it's indeed refers the bundle, so it's packaged and minified for best performance.

You might say, that 1. this is out of scope for System.Web.Optimization framework 2. you can create this behavior easily on your own. This is right, but in the same time if you deal with ASP.NET MVC4 you have some expectation that is should work right and you are not forced to invent the wheel again, so you have kind of consistency between numerous projects.

I've been thinking about to create something like that, but during the chat with fellow developer @andrexx about bundling and he showed me something interesting. Tom DuPont has already implemented something that's really reflects my needs. It's the way of configuring bundles both from code and web.config. It looks like a very handy tool.

New in ASP.NET MVC4: Bundling and Minification

2012-04-02T09:44:00.000+03:00

Next new feature that appeared in MVC 4 beta is bundling and minification. Idea is simple: modern web application contains of many static resources, especially css and javascript files. To load the page browser have to load each resource. Each resource is being requested by HTTP request. Browser have to make as many request as page refers, wait till all are completed and only after that render the page.

The problem is, each HTTP request takes time. One of the most critical Yahoo web applications performance recommendation says - Minimize HTTP request. As few HTTP requests you need to load application as better.

System.Web.Optimization

Bundling and minification is located in it's own namespace System.Web.Optimization and resides in assembly named Microsoft.Web.Optimization, which is installed by default with new ASP.NET MVC4 application template as NuGet package. Since it's still in beta, namespaces and class names are probably be changing, but let's look on that we have now.

What is bundle?

Bundle is simply logical group of files that could be referenced by unique name and being loaded with one HTTP request. Suppose, we have a Layout.cshtml that might look something like that:

<meta charset="utf-8" />

<title>@ViewBag.Title</title> 
        
<link rel="stylesheet" href="~/Content/jquery.mobile-1.0b3.min.css" />
<link rel="stylesheet" href="~/Content/reset.css" />
<link rel="stylesheet" href="~/Content/foundation.css" />
<link rel="stylesheet" href="~/Content/Fonts.css" />
<link rel="stylesheet" href="~/Content/Site.Layout.css" />
<link rel="stylesheet" href="~/Content/Site.Mobile.css" />

<script type="text/javascript" src="~/Scripts/jquery-1.6.4.js"></script>
<script type="text/javascript" src="~/Scripts/jquery.mobile-1.0b3.js"></script>
<script type="text/javascript" src="~/Scripts/knockout-2.0.0.js"></script>
<script type="text/javascript" src="~/Scripts/underscore.js"></script>
<script type="text/javascript" src="~/Scripts/App/CacheInit.js"></script>

You can see, that's a lot of css and javascript that will be loaded for page. With bundling we can rewrite it with very simple code

<meta charset="utf-8" />

<title>@ViewBag.Title</title> 
        
<link rel="stylesheet" href="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Content/css")" />

<script type="text/javascript" src="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Scripts/js")"></script>

In this case "~/Content/css" and "~/Scripts/js" are no longer virtual paths, but bundle names.

The the browser would load this page, rendered HTML would look like:

<link href="/Content/css?v=q_sftc19r22licIM8-Ar58FwviyWry1JuYbA-iATm4M1" rel="stylesheet" type="text/css" />
<script src="/Scripts/js?v=_8kyYWxz-Je_VE0p3_w5nbcjAhq0Qj4vZiNxvYU_oBg1"></script>

Note, it would reference the bundle with version. The version is a kind of hash taken on all files in bundle content. This enables browser caching, if content of bundle is not change browser will take it from cache, which is much faster. In case of changes, new version token is generated, so browser would be forced to reload bundle.

Bundle registration

In global.asax file you will see new line:

    BundleTable.Bundles.RegisterTemplateBundles();

It's only one small line of code that enables bundling and minification framework.

RegisterTemplateBundles() vs. EnableDefaultBundles()

It looks fine so far, so I tried to add new javascript file into Scripts folder. Unfortunately, my application did not work. I think this is first very contra-intuitive fact of bundling framework. Googling a bit I found quick solution, change RegisterTemplateBundles() to EnableDefaultBundles().. I tried that and it really works.

Since the System.Web.Optimization has not been opened sourced yet (in case you haven't heard - ASP.NET web stack is open source, even with accepting pull request) I had to go to JustDecompile to understand why is that.

So, RegisterTemplateBundles() is looks like that,

public void RegisterTemplateBundles()
{
    bool flag;
    bool flag2;
    bool flag3;
    bool flag4;
    bool flag5;
    bool flag6;
    bool flag7;
    Bundle bundle1 = new Bundle("~/Scripts/js", new JsMinify());
    bool flag8 = false.AddDirectory("~/Scripts", "jquery-*", flag, flag8);
    bool flag9 = false.AddDirectory("~/Scripts", "jquery.mobile*", flag2, flag9);
    bool flag10 = false.AddDirectory("~/Scripts", "jquery-ui*", flag3, flag10);
    bool flag11 = false.AddDirectory("~/Scripts", "jquery.unobtrusive*", flag4, flag11);
    bool flag12 = false.AddDirectory("~/Scripts", "jquery.validate*", flag5, flag12);
    bool flag13 = false.AddFile("~/Scripts/MicrosoftAjax.js", flag13);
    bool flag14 = false.AddFile("~/Scripts/MicrosoftMvc.js", flag14);
    bool flag15 = false.AddDirectory("~/Scripts", "modernizr*", flag6, flag15);
    bool flag16 = false.AddFile("~/Scripts/AjaxLogin.js", flag16);
    this.Add(bundle1);
    Bundle bundle2 = new Bundle("~/Content/css", new CssMinify());
    bool flag17 = false.AddFile("~/Content/site.css", flag17);
    bool flag18 = false.AddDirectory("~/Content/", "jquery.mobile*", flag7, flag18);
    this.Add(bundle2);
    Bundle bundle3 = new Bundle("~/Content/themes/base/css", new CssMinify());
    bool flag19 = false.AddFile("~/Content/themes/base/jquery.ui.core.css", flag19);
    bool flag20 = false.AddFile("~/Content/themes/base/jquery.ui.resizable.css", flag20);
    bool flag21 = false.AddFile("~/Content/themes/base/jquery.ui.selectable.css", flag21);
    bool flag22 = false.AddFile("~/Content/themes/base/jquery.ui.accordion.css", flag22);
    bool flag23 = false.AddFile("~/Content/themes/base/jquery.ui.autocomplete.css", flag23);
    bool flag24 = false.AddFile("~/Content/themes/base/jquery.ui.button.css", flag24);
    bool flag25 = false.AddFile("~/Content/themes/base/jquery.ui.dialog.css", flag25);
    bool flag26 = false.AddFile("~/Content/themes/base/jquery.ui.slider.css", flag26);
    bool flag27 = false.AddFile("~/Content/themes/base/jquery.ui.tabs.css", flag27);
    bool flag28 = false.AddFile("~/Content/themes/base/jquery.ui.datepicker.css", flag28);
    bool flag29 = false.AddFile("~/Content/themes/base/jquery.ui.progressbar.css", flag29);
    bool flag30 = false.AddFile("~/Content/themes/base/jquery.ui.theme.css", flag30);
    this.Add(bundle3);
}

As you can see it adds all recourses that came just in template, including jQuery Mobile and jQuery UI.

In the same time, EnableDefaultBundles()

public void EnableDefaultBundles()
{
    this.Add(new DynamicFolderBundle("js", JsMinify.Instance, "*.js"));
    this.Add(new DynamicFolderBundle("css", CssMinify.Instance, "*.css"));
}

So, what it does - it matches all javascript and css files in project, minify them and create to bundles out of it.

As you can see EnableDefaultBundles() is also uses Minification policy for bundle content.

How add my own custom bundle?

As simple as create new Bundle object, put files inside and then add it to Bundles collection.

var bundle = new Bundle("~/Scripts/libs", new JsMinify());
bundle.AddFile("~/Scripts/knockout-2.0.0.js");
BundleTable.Bundles.Add(bundle);

But there two issues here. First of all, you don't always want to minify. Second, adding bundles with many files will make global.aspx.cs looks messy. I really liked approached proposed by Scott K. Allen in his Yet Another Bundling Approach for MVC 4 blog post. He does it in more object-oriented way including smart code to decide, should the bundle be minified or not. All you need is just take code he created and after you are able to make bundles like that.

public class JsLibsBundle : JsBundle
{
    public JsLibsBundle() : base("~/js/libs")
    {
        AddFiles(
            "~/Scripts/jquery-1.6.4-vsdoc.js",
            "~/Scripts/jquery-1.6.4.js",
            "~/Scripts/jquery.mobile-1.0b3.js",
            "~/Scripts/knockout-2.0.0.js",
            "~/Scripts/modernizr-2.0.6-development-only.js",
            "~/Scripts/underscore.js"
        );
    }
}

public class CssAppBundle : CssBundle
{
    public CssAppBundle() : base("~/css/mobile")
    {
        AddFiles(
            "~/Content/jquery.mobile-1.0b3.css",
            "~/Content/Site.Mobile.css"
        );
    }
}

And put them to registered those classes in global.asax.cs

    BundleTable.Bundles.Add(new JsLibsBundle());
    BundleTable.Bundles.Add(new CssAppBundle());

Ok, how all that stuff works?

Now let's do a really brief look under the hood. Again, JustDecompile is our friend here.

It was interesting to me to find out new cool way of registration modules in ASP.NET. No longer entry points in web.config or other magic. You can have a special class PreApplicationStartCode that would be called then assembly is loaded, but before application is stated.

public static class PreApplicationStartCode
{
    private static bool _startWasCalled;

    public static void Start();
}

Here System.Web.Optimization register it's own module, called BundleModule.

public static void Start()
{
    if (PreApplicationStartCode._startWasCalled)
    {
        return;
    }
    PreApplicationStartCode._startWasCalled = 1;
    DynamicModuleUtility.RegisterModule(typeof(BundleModule));
}

Then the module is intialized, it subscribes for event called HttpApplication.PostResolveRequestCache and inside the callback it would register the BundleHandler.

private void OnApplicationPostResolveRequestCache(object sender, EventArgs e)
{
    HttpApplication httpApplication = (HttpApplication)sender;
    if (BundleTable.Bundles.Count > 0)
    {
        BundleHandler.RemapHandlerForBundleRequests(httpApplication);
    }
}

The handler is now responsible for dirty job. Through the RequestBundle class it finally comes to ProcessRequest method.

internal void ProcessRequest(BundleContext context)
{
    context.EnableInstrumentation = Bundle.GetInstrumentationMode(context.HttpContext);
    BundleResponse bundleResponse = this.GetBundleResponse(context);
    Bundle.SetHeaders(bundleResponse, context);
    context.HttpContext.Response.Write(bundleResponse.Content);
}

So, the GetBundleResponse is there magic is happens.

private BundleResponse GetBundleResponse(BundleContext context)
{
    BundleResponse bundleResponse = Bundle.CacheLookup(context);
    if (bundleResponse == null || context.EnableInstrumentation)
    {
        bundleResponse = this.GenerateBundleResponse(context);
        if (!context.EnableInstrumentation)
        {
            Bundle.UpdateCache(context, bundleResponse);
        }
    }
    return bundleResponse;
}

What's important here is that it uses cache. So, it makes bundling rather efficient. In case if there are no cached result, it will run the GenerateBundleResponse to generate actual response:

public virtual BundleResponse GenerateBundleResponse(BundleContext context)
{
    if (context == null)
    {
        throw new ArgumentNullException("context");
    }
    IEnumerable<FileInfo> fileInfos = this.EnumerateFiles(context);
    fileInfos = context.BundleCollection.IgnoreList.FilterIgnoredFiles(fileInfos);
    fileInfos = this.Orderer.OrderFiles(context, fileInfos);
    fileInfos = this.ReplaceFileExtensions(context, fileInfos);
    string str = this.Builder.BuildBundleContent(this, context, fileInfos);
    BundleResponse bundleResponse = new BundleResponse(str, fileInfos);
    this.Transform.Process(context, bundleResponse);
    return bundleResponse;
}

Yet another interesting finding here is this.Orderer. Sometime ago I did smalltalk on Kiev ALT.NET meeting about new stuff in VS2011 and being asked a question, how is possible to order the files. I didn't know answer then. It is actually possible to setup the order of files inside bundle, in case you have cross-file dependencies:

public interface IBundleOrderer
{
 IEnumerable<FileInfo> OrderFiles(BundleContext context, IEnumerable<FileInfo> files);
}

That's it, the generated response than just being written to context.HttpContext.Response.

Conclusions

Bundling and minification is something that I personally wanted so much, to appear in new MVC framework. Now it's there, it works.. but I would not say I'm 100% happy. There are several things that makes it a little difficult to use, as for me. I did want to place it in this post, but appeared to big.. So, I'll probably do a separate one on this matter.

MS SWIT 2012

2012-03-27T09:26:00.000+03:00

The 22-23 of March this year I had a chance to participate biggest event organized by Microsoft Ukraine - MS SWIT 2012.

It's been almost two years ago I visited MS SWIT 2010. If the primary topic of last conference was cloud technologies - Azure, SQL etc. This time I would say the buzz was around Windows 8, Market Place and Metro-style applications. Of cause, there was still a lot of attention to Azure as well.

I really much enjoyed the Keynote of first day by Wolfgang Ebermann. Indeed, Microsoft opens pretty much interesting opportunities for developers on Windows 8 and Windows Phone markets. Not long time ago Ukraine officially is a part of MarketPlace, so no time to wait - go and create you first Metro style app. And with new Microsoft policies regarding adoption of open standards like HTLM5, EcmaScript - it looks really attractive to me.

Big attention was also about new recent releases like: Share Point, SQL Server Denali, Windows Server 8 etc. I would not say this is exactly interesting to me, since I more focus on web technologies, but it's always good to be aware what's going on around. First day of conference got a lot people moving around, so if you wanted to listen for some interesting speech you have to be in time to get free sit. Second day was not so overcrowded as for me, so the people who didn't come have to be sorry, cause Second day was much more interesting.

My talk was about new stuff in ASP.NET MVC4, with more focus to mobile web applications. That was the biggest audience I ever speak to. There was almost no free sits.. I don't know for sure it contained 150-200 people.. Huge!

Being much inspired by Steve Sanderson talk on TechDays 2012, I decided to make something similar. I came up with idea of simple mobile web application, namely it is a web client to http://asp.net portal and develop it just during the speech. I had several issue's there, first one I did a little more longer introduction and then some issues with internet that made me a little nervous and I lose tempo a bit. That forced me to skip the last part of talk regarding Offline mode for apps. Anyway, I hope I was able to show new sweet available stuff like CSS3 Media Queries, Display Modes and jQuery Mobile framework.

Thanks a lot for everyone who listened to me and came up with questions. I appreciate your attention and hope my talk was useful for you.

Regarding the app, I polished it a bit and going to release closer to the end of next week. The sources are hosted on https://github.com/alexanderbeletsky/aspnet.mobile, feel free to clone and send a pull request.

New in ASP.NET MVC4 Beta: Web API

2012-03-20T18:54:00.000+02:00

This is a high level overview of new stuff that appeared within VS2011 release. So, let's briefly look inside. Today will take a look on changes appeared to Web API.

Web API

The biggest and most important change as for me is integration of Web API into ASP.NET. Web API is most known as WCF Web API - an attempt of .NET team build framework for creation of RESTfull services based on WCF infrastructure. There was several releases of WCF Web API made and general feedback from community was - "it's good enough". Since when, Microsoft did a strategic change, merged WCF Web API and ASP.NET teams together, so both products to be developed in sync. From now Web API is integral part of ASP.NET (and does not have any WCF prefix any more) and called ASP.NET Web API. It is not just re-branding, but it reflects changes both the programming model and processing architecture.

Simple Start

If we create a new ASP.NET MVC4 application, we see the following change into global.asax file.

routes.MapHttpRoute(
    name: "DefaultApi",
    routeTemplate: "api/{controller}/{id}",
    defaults: new { id = RouteParameter.Optional }
);

MapHttpRoute is new extension method for RouteCollection. Similarly to ASP.NET MVC routing definition, it maps HTTP request with matching URL into corresponding API controller action. By default, the are all prefixed with "api" to do not "interfere" to ASP.NET MVC routing. It's not a problem to change that prefix to anything you want, like "services", "methods" etc.

    /api/contacts/      <- Web API
    /api/contacts/1     <- Web API
    /contacts/1         <- ASP.NET MVC

The API controllers are really similar to ASP.NET MVC controllers. Instead of inherit from Controller class, they inherited from ApiController class. Instead of returning ActionResult from action, in API controllers you return either IEnumerable or concrete instance, like Product (there are some more dedicated scenarios with returning types, we will see later).

By just looking into example from project template it is very easy to understand, what's going on. There are some small details you should know before API controller usage.

Action methods naming

API controllers are "Convention over configuration" based. The actual HTTP verb that action handles could be specified in method name.

public class ProductsController : ApiController
{
    // Handles GET
    public IEnumerable<Product> Get() { }
    // Handles POST
 public Product Post(Product product) { }
    // Handles PUT
 public Product Put(Product product) { }
    // Handles DELETE
 public void Delete(int id) { }
}

This convention applies only to GET, POST, PUT, and DELETE methods. You might be more specific in methods names, like GetProducts or DeleteProduct, the important is the prefix (Get, Post, Put etc.) of method.

If you don't want to rely of named based conventions, you can explicitly specify target HTTP verb by decorating methods with HttpGet, HttpPut, HttpPost, or HttpDelete attribute.

public class ProductsController : ApiController
{
    [HttpGet]
    public IEnumerable<Product> AllProducts() { }
    [HttpPost]
 public Product CreateProduc(Product product) { }
    [HttpPut]
 public Product UpdateProduct(Product product) { }
    [HttpDelete]
 public void DeleteProduct(int id) { }
}

One handler per one controller

API Controller are different from ASP.NET MVC controller. The main difference is that API controller handles exactly one HTTP request belongs to particular entity.

If you try to create the code like:

public class ProductsController : ApiController
{
    public IEnumerable<Product> Get() { }
    public IEnumerable<Product> GetAnother() { }
}

It would be build OK, but on a runtime if you try to access '/api/products', you will get an exception:

"Multiple actions were found that match the request: 
\u000d\u000aSystem.Collections.Generic.IEnumerable`1[MvcApplication7.Api.Controllers.Product] 
Get() on type MvcApplication7.Api.Controllers.ProductsController\u000d\u000aSystem.Collections.Generic.IEnumerable`1[MvcApplication7.Api.Controllers.Product] 
GetAnother() on type MvcApplication7.Api.Controllers.ProductsController"

The less stuff is very similar to something we get used in ASP.NET MVC. And you might think - why do we need this Web API at all, I can do exactly the same stuff with good-n-old ASP.NET MVC controllers? Not exactly. Web API has several killer features that makes it favorite for data oriented API's. Let's go on.

Content Negotiation

Content Negotiation is the process for mutual agreement between client and server about the received/sent data formats. Good news here, Web API does a lot of job for you, leaving content negotiation internals behind the scene. Let's take a brief look of how things happen.

When client sends HTTP request to server, besides the query string and payload it also provides different kind information. This information is being placed into HTTP header and provides server with specific details for better understanding each other. In particular, it contains Accept header field which specifies client preferences on response format. I'm going use Fiddler to check how Web API behaves on different conditions.

First, let's do not specify the Accept field at all. So, the payload we going to send to server from our client (Fiddler) will be like:

    GET /api/products HTTP/1.1
    User-Agent: Fiddler
    Host: localhost:5589

For that request, we will receive the response like:

    HTTP/1.1 200 OK
    Cache-Control: no-cache
    Pragma: no-cache
    Content-Type: application/json; charset=utf-8
    Expires: -1
    Server: Microsoft-IIS/7.5
    X-AspNet-Version: 4.0.30319
    X-SourceFiles: =?UTF-8?B?RDpcRGV2ZWxvcG1lbnRcUHJvamVjdHNcZXhwZXJpbWVudHNcTXZjQXBwbGljYXRpb243XE12Y0FwcGxpY2F0aW9uN1xhcGlccHJvZHVjdHM=?=
    X-Powered-By: ASP.NET
    Date: Mon, 19 Mar 2012 17:31:23 GMT
    Content-Length: 88

    [{"Description":"iPad","Id":1,"Price":1000},{"Description":"iPhone","Id":2,"Price":500}]

As you can see, the default Content-Type is "application/json; charset=utf-8", there is a json string in HTTP response payload.

Let's make our request a little more specific.

    GET /api/products HTTP/1.1
    User-Agent: Fiddler
    Host: localhost:5589
    Accept: text/xml

The corresponsing response:

    HTTP/1.1 200 OK
    Cache-Control: no-cache
    Pragma: no-cache
    Content-Type: text/xml; charset=utf-8
    Expires: -1
    Server: Microsoft-IIS/7.5
    X-AspNet-Version: 4.0.30319
    X-SourceFiles: =?UTF-8?B?RDpcRGV2ZWxvcG1lbnRcUHJvamVjdHNcZXhwZXJpbWVudHNcTXZjQXBwbGljYXRpb243XE12Y0FwcGxpY2F0aW9uN1xhcGlccHJvZHVjdHM=?=
    X-Powered-By: ASP.NET
    Date: Mon, 19 Mar 2012 17:33:34 GMT
    Content-Length: 329

    <?xml version="1.0" encoding="utf-8"?><ArrayOfProduct xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><Product><Id>1</Id><Description>iPad</Description><Price>1000</Price></Product><Product><Id>2</Id><Description>iPhone</Description><Price>500</Price></Product></ArrayOfProduct>

As you can see, without any code changes we made it "adapt" for particular client needs. This is a very decent feature of Web API and available for use, just from the box. You even don't need to care about it at all. Leave the content negotiation for the infrastructure.

IQueryable<T> Support

Next cool feature is IQueryable<T> support. If you need to, instead of returning "plain" IEnumerable objects from the API action, you might return IQueryable<T>. Why?

Remember the times we implemented paging & sorting with ASP.NET MVC application. It was possible of cause, but it required a lot of manual job. Actions had to be extended with additional parameters, code have to respect those parameters and return exact portion of data we require to. The same story with sorting. In Web API it much simpler.

Change the signature and return type to IQueryable.

public IQueryable<Product> Get()
{
    return _storage.AsQueryable();
}

Now, if Web API sees the method like that, it will allow to access with with Open Data Protocol (OData) query string parameters. OData provides support for following queries: $filter, $orderby, $skip, $top.

Now, if I do the request:

    http://localhost:5589/api/products?$top=3

I will receive, 3 top products. Or something like,

    http://localhost:5589/api/products?$skip=2&$top=3

I will skip 2 and take rest 3. In short, having IQueryable and 4 OData query parameters it's much more easy to do the stuff required more time before.

Hosting

Hosting is a feature of Web API allow to run service inside the different hosts. What does it mean?

We are much get used to ASP.NET hosting as default. I saw no problem with that at all till working on one of my recent projects. The problem is for ASP.NET pipeline you need to have a web server (IIS), but web server always have some limitations (permissions and stuff). For simple things, that does not require any IIS benefits it is easier to host application just in .exe assembly. It's now possible with Web API.

We have several hosting providers out of the box: self-hosting and web-hosting. Besides of that there are already some provided by community Louis DeJardin created a host on top of OWIN and Pedro Félix host for Azure.

Also, there is a great article by Pedro Felix about in-memory hosting. This is very useful type of hosting for unit testing of services.

IoC improvements

Since Web API now is inside ASP.NET MVC, it uses the same strategy of resolving types by IDependencyResolver. That means that Web API classes are now supporting same IoC style as ASP.NET MVC controller classes. Being setup once you can put different dependencies inside API class constructor.

public class ProductsController : ApiController
{
 public ProductsController(IServiceProvider service, IRepository<Product> productRepository)
 {
  // .. 
 }

Conclusions

This is not everything, but very light overview of new stuff coming within ASP.NET MVC4. ASP.NET Web API is very nice addition to framework. There are already some good feedback, so let's hope it will be even more improved toward release.

VS2011 Beta is Ready for Review

2012-03-15T11:15:00.000+02:00

29 February (leap day and huge failure of Azure Cloud) is the day then VS2011 Beta community preview has been released. As a lot of geeks around the globe I've downloaded installation image and tried it on my computer. With VS2011 Beta we also received .NET 4.5 framework and (drums here) - ASP.NET MVC4 Beta, that I really wanted to try since first CTP is out. I would not say I spent too much time with both products, but I already have some initial opinion on that.

VS2011 installation..

Well, I had some not really good experience with beta versions of VS2010 and compatibility between two visual studios on the same machine. Situation is different with VS2011. Installation very pretty smooth, I just run it on background while was working through RDP on another machine and it installed without any interaction. Whole process took about 40 minutes.

VS2010 and VS2011 beta could happily leave together without any interference. Moreover, you can freely work with your existing VS2010 solutions. Solutions for .NET 4, 3.5 and 2.0 are still supported in the same good way.

.. and first launch

VS2011 "cold" start up is a faster (about 40 seconds against 90 seconds, on my machine). The only one reason I see is VS2011 is not yet overloaded with different plugins I use in VS2010.

First very noticeable change is of cause the design. There were many blog posts with preview of VS2011 design before the beta release. And you know, I really liked what I saw on images. I changed my opinion on first launch. Probably it's just the matter of taste or habits, but new VS design looks awful to me (especially in Dark Theme - 80's monochrome display back!). It's totally grey, with no colors in icons at all. Fonts are in METRO style (all uppercase) looks very unusual. Solution explorer contains grey icons, it's a little difficult to distinguish between project types and file types inside. So, fellow developer - get ready to order new glasses since you decide to switch to VS2011.

Nevertheless, I was happy to open my exiting solution, press Ctrl + Shift + B and it successfully built. The good thing is .sln file has not been transformed (except the Format Version 11.00 has been changed to Format Version 12.00) so it's still can be opened both VS2010 and VS2011.

It also has been imported all my VS2010 settings. It is really nice, since you don't need to spent much time setting up favorite color scheme and key bindings.

I haven't seen any noticeable performance changes. Sometimes VS2011 works a little slower as for me (please note, this is only subjective feelings, does not pretend to be absolute truth). Looks like VS2011 has much larger memory footprint.

And for some mystical reason it spawns second devenv.exe process in a while, even if I have only one VS instance running.

Code editing

Code editor is almost the same. No new refactoring tools, no support of 3rd parties Unit Test systems (NUnit, XUnit etc.) from the box. Still Visual Studio requires to have ReSharper for more productive coding. My dream of using clean VS with minimum plugins installed seems not gonna come true with VS2011.

Some few nice moments I noticed for HTML/Razor/CSS editors. First of all, it updates closing HTML tag if you changed opening one (and vice versa). For CSS, it has much more better InteliSence + nice feature of picking colors.

I haven't noticed any significant changes to JS editor. Except the fact, that there are no 'Update JScript Intellisense' menu command, so I suppose that now it's done automatically. Still, it's very primitive and does not work all the time. For instance, I haven't managed to get any InteliSense during working with Knockout.js library, maybe I'm just doing something wrong.

I want my plugings

So, VS2011 is generally OK, so I would prefer to use it. Hope a lot of new fixes and some feature still will be included in RC.

What I personally lack is 2 plugins. ReSharper and NCrunch. Fortunately both appeared very fast. Remco Mulder released NCrunch 1.38b and JetBrains are came with ReSharper 7 EAP which is free for download and evaluation. Both plugins works really fine. Having good refactoring tools as ReSharper gives and having the power of Continuous Tests with NCrunch, makes the VS2011 ready to use IDE.

Conclusions

The beta looks very promising.. and in general it works fine! Except the design, nothing really new to IDE as for me. Probably I spent to few time to feel the power, so I'll be updating if I see some cool or bad features. The most sweet things with new VS is surely updated .NET framework and MVC. I'm now trying to play with new stuff and much as I can, already checked some new nice stuff of MVC4 framework.

Second Year of E-conomic

2012-03-13T19:40:00.000+02:00

Yeah, it's been 2 years since I joined the e-conomic company. As it was last year, this year e-conomic still plays very important role in my life, so I'll spent some time to write this blog post.

Well, a lot of things changed I would say. Some people came, some people left. Teams rotating all the time, I'm no longer work with guys I used to work last year. We are doing revolutionary things there, no doubts. It doesn't mean, we are creating new search engines or inventing new type of computer. No, we are revolutionizing ourselves much.. doing the same type of products, but doing it differently.

Remember I wrote about how technologies helps to move product faster - that was an example of radical changes in framework and tools we did to successfully deliver the product. I believe something happened last year, something that gave much pulse for changes. And that pulse still affects us. We went much further of changing for Web Forms to MVC or jQuery to Backbone.js. Recently our back-end team finished up POC of using node.js + MongoDB as our perspective server side technology stack. And they actually proved that it will work for us.

From my perspective, e-conomic much improved in this year. And this is of cause happened, because people how work in e-conomic improved. Without any hesitate, I would say that currently we have the strongest team ever. Both Danish and Ukrainian parts. It's amazing how smooth the technologies change was, how fast new concepts been adopted, how motivated and hardworking guys joined together.

We've been empowered not only by engineers, but also with our newly assembled UI/UX team. No secret, everybody want to work with beautiful things. I equally appreciate both the quality of code and quality of design. And this is want UI/UX team care about. And this is fantastic job as for me. We are changing the design quite regularly and each iteration it turns better and better. Colors, fonts, usability tricks - that's something that gives a life to modern web applications.

As usually the developers see only the tip of iceberg of whole company business, but I really hope that all good stuff that's happening inside engineering department will find it's reflection in quality of service, usability and user happiness.. that at the end of the day bring the company more users and more money. Sure, the things are moved not only by developers. I would say, we are doing the easiest job. Our PO's and Stakeholders - that's where ideas are coming from. The quality of those "ideas" are directly proportional to output quality. And this quality is getting better and better each day.

We are doing finishing strokes on new product, called Debitoor.com. It's amazing application and I hope it will find it's audience very fast.

So, I'll say goodbye to the past year and look forward for new journeys in next one.

Foundstyles.com - Ready to use styles based on Foundation

2012-03-07T14:54:00.000+02:00

Foundstyles.com is a little project I've been working for last week. The idea is very simple. Remember, I blogged about Foundation Framework that works pretty nice for me. So, I've decided to do something similar that exist for twitter bootstrap framework - bootswatch ready to pickup .css that could be easily integrated to your site. Today the site is available!

Unfortunately Foundation does not support LESS from the package, so I need to move colors and layout into corresponding .LESS files, so after it's just possible to have a basic template which is possible to customize with own colors.

As for now, I've created only 3 templates: Blades Of Steel, Evergreen Tree and Coffee and Milk.

I had a lot of joy making those styles. Making web designs and playing with colors is my next hobby, I think. Through, those styles are really simple ones, I'm going to add more eventually. Since the project is just hosted on github you are able to push you own styles. If you feel inspired, I would be really happy for submissions.

Nearest plans are apply some fixes for IE (both site and styles) and just go ahead and produce some more. Hope it could be useful for you guys.

NancyFX Migration from 0.9 to 0.10

2012-02-29T12:16:00.000+02:00

Recently, I've upgraded IdeaStrike project from NancyFX 0.9 to the latest 0.10 version. There were some very unclear moments, fortunately due to great support of @thecodejunkie and @grumpydev they are solved. As a result, the issue 520 was born, that contains a lot of text inside. I'll try to sum up all important things into one blog post.

Running update

With NuGet updating dependencies is very easy, just run in package manager console:

    PM> update-package

It will give you the information about the upgrade process, it should be very smooth, so the end you will see:

Successfully uninstalled 'Nancy.Hosting.Aspnet 0.9.0'.
Updating 'Nancy.Testing' from version '0.9.0' to '0.10.0' in project 'IdeaStrike.Tests'.
Successfully removed 'Nancy.Testing 0.9.0' from IdeaStrike.Tests.
Successfully removed 'Nancy 0.9.0' from IdeaStrike.Tests.
Successfully added 'Nancy 0.10.0' to IdeaStrike.Tests.
Successfully installed 'Nancy.Testing 0.10.0'.
Successfully added 'Nancy.Testing 0.10.0' to IdeaStrike.Tests.
Successfully uninstalled 'Nancy.Testing 0.9.0'.
The directory is not empty.

Successfully uninstalled 'Nancy 0.9.0'.

Fixing compilation errors

As you try to build the project after upgrade, it would fail because of compilation issues.

If you using Nancy bootstrapper and overriding RequestStratup method, you will see that method had changed the signature:

    // in 0.9
    protected override void RequestStartup(ILifetimeScope container, IPipelines pipelines);

    // in 0.10
    protected override void RequestStartup(ILifetimeScope container, IPipelines pipelines, NancyContext context)

So, it now receives additional parameter - NancyContext.

Next compilation errors is inside the Request.Headers.AcceptLanguage.

    // in 0.9
    public IEnumerable<string> AcceptLanguage { get; }
    
    // in 0.10
    public IEnumerable<Tuple<string, decimal>> AcceptLanguage { get; }

Both of these compilation errors are really easy to fix. See changes to src/Ideastrike.Nancy/IdeastrikeBootstrapper.cs in this commit.

After that, the compilation will be fine. I had to restart my Visual Studio after, since NCrunch was failing to compile the application.

Fixing failing unit tests

After VS is restarted and NCrunch able to pick up changes, I got 3 unit tests failures. All of them with the similar exception, like:

    System.Exception: System.Exception : ConfigurableBootstrapper Exception
    ---- Nancy.RequestExecutionException : Oh noes!
    -------- Nancy.ViewEngines.ViewNotFoundException : Unable to locate view '404'. Currently available view engine extensions: sshtml,html,htm,cshtml,vbhtml
    at Nancy.Testing.PassThroughErrorHandler.Handle(HttpStatusCode statusCode, NancyContext context)
    at Nancy.NancyEngine.CheckErrorHandler(NancyContext context)
    at Nancy.NancyEngine.HandleRequest(Request request)
    at Nancy.Testing.Browser.HandleRequest(String method, String path, Action1 browserContext)
    at Nancy.Testing.Browser.Get(String path, Action1 browserContext)
    at IdeaStrike.Tests.IdeaStrikeSpecBase1.Get(String path, Action1 browserContext) in D:\Development\Projects\Ideastrike\tests\IdeaStrike.Tests\IdeaStrikeSpecBase.cs:line 85

That was a mystery. All of those tests were fine, but suddenly stopped to work in 0.10.

The reason was very interesting. Those tests for views were actually never run. It's been unseen for 2 reasons: Nancy 0.9 failed silently about missing view, IdeaStrike unit tests never tested view content.

To make those run, the IdeaStrikeSpecBase have to be setup with IRootPathProvider. IRootPathProvider, provides the path root for modules, so views could be located, based on default conventions. I finished up with this implementation:

public class CustomRootPathProvider : IRootPathProvider
{
    public string GetRootPath()
    {
        return Path.GetDirectoryName(typeof(IdeastrikeBootstrapper).Assembly.Location);
    }
}

This root provider is used with spec base class configuration:

public IdeaStrikeSpecBase()
{
 Bootstrapper = new ConfigurableBootstrapper(with =>
 {
  with.Module<TModule>();
  with.Dependencies(_Users.Object, _Ideas.Object, _Features.Object, _Activity.Object, _Settings.Object, _Images.Object);
  with.DisableAutoRegistration();
  with.NancyEngine<NancyEngine>();
  with.RootPathProvider<CustomRootPathProvider>(); // <- Here
 });
}

So, we are saying that root is the same folder as IdeaStike assembly. The problem is that location depends on actual Test runner. In case of NCrunch, it would be some deeply hidden folder in user\AppData\Local\Temp, in case of ReSharper runner it would be temp ASP.NET folder. That's a little annoying.

Tests were still red, since neither NCrush nor ReSharper is copying actual views into target folder. Fortunately, I found this great article, explaining NancyFX view testing gotchas. I ended up with just saying “Copy if newer” for views under test, so they are in the same folder as target binary. That's not cool, but currently I see no other option.

After those changes, tests became green, so I run the application. No surprise, it failed to start.

Fixing runtime errors

At the first run, I got nothing more as bunch of Razor compilation errors:

    Error Compiling Template: (51, 18) The name 'Url' does not exist in the current context)
    Error Compiling Template: (61, 33) The name 'Model' does not exist in the current context)
    Error Compiling Template: (68, 26) The name 'Model' does not exist in the current context)
    Error Compiling Template: (78, 7) The name 'Model' does not exist in the current context)
    Error Compiling Template: (83, 31) The name 'Model' does not exist in the current context)
    Error Compiling Template: (88, 14) The name 'Model' does not exist in the current context)
    Error Compiling Template: (103, 14) The name 'Model' does not exist in the current context)
    Error Compiling Template: (118, 14) The name 'Model' does not exist in the current context)
    Error Compiling Template: (132, 25) The name 'Model' does not exist in the current context)
    Error Compiling Template: (234, 19) The name 'Url' does not exist in the current context)

The proposed solution that NancyRazorViewBase should always be specified with generic parameter.

    // in 0.9
    @inherits Nancy.ViewEngines.Razor.NancyRazorViewBase

    // in 0.10 
    @inherits Nancy.ViewEngines.Razor.NancyRazorViewBase<dynamic>

OK, that helped a little, but right after that error saying System.Web.IHtmlString type is not references:

    Error Compiling Template: (83, 1) The type 'System.Web.IHtmlString' is defined in an assembly that is not referenced. You must add a reference to assembly 'System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'.)

NancyFX is being developed to be independent of System.Web. It was not totally true for 0.9 with Razor support, but it has been fixed in 0.10. That of cause, brings some surprises. So, if your application is using Razor view engine, you need to do following:

update all usages of IHtmlString to use Nancy.ViewEngines.Razor.IHtmlString
update all usages of McvHtmlString to use Nancy.ViewEngines.Razor.NonEncodedHtmlString
let the razor engine know about system.web (in case if HttpContext is used in layout)

<razor disableAutoIncludeModelNamespace="false">
    <assemblies>
        <add assembly="System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
    </assemblies>
    <namespaces>
        <add namespace="System.Web" />
    </namespaces>
</razor>

Changing the Partial views

After these steps were done, application finally started. But some page gave runtime exception:

Server Error in '/' Application.

Sequence contains no elements

Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code. 

Exception Details: System.InvalidOperationException: Sequence contains no elements

My dump analisys showed, that it works fine as soon as I removing partial views:

    @Html.Partial("Shared/Templates/upload.html")
    @Html.Partial("Shared/Templates/download.html")

The reason turned out to be really simple. All templates in IdeaStrike project were using .html extension. For 0.10 it required to be .cshtml. So, renaming from .html to .cshtml made the IdeaStrike up and running again.

Speeches Hat-Trick For This Weekend

2012-02-27T10:30:00.000+02:00

It's been great weekend. It started Friday evening with Kiev ALT.NET meet-up which been in idle for a while and everybody missed that. There was a three planned speeches: by @_TKL on Continuous Testing (NCrunch, MightyMoose), NancyFX framework by me and FubuMVC by @skalinets.

I would not say I got great experience on Nancy so far. But I'm pretty exited on frameworks features and super-dupper-happy-path. Almost all knowledge I gathered thought hacking of IdeaStrike, listening to Herding Code episode and reading documentation. But anyway, I believe it turns out to be good introductory presentation.

Right after my Nancy talk I moved to central train station, since I was about to visit Ciklum .NET Saturday in Dnepropetrovsk. .NET Saturday's is just great initiative by Ciklum company. I's free event, everybody welcome, content is usually nice. I highly recommend to follow their events.

I had two talks there. First one about "Continuous Delivery" that I did on Agile Base Camp 2012. Besides of the talk I also did a quick and improvised demo of Candidate application. Even if I had some technical issues the demo went fine.

Another one is for logging and tracking unhandled exceptions in ASP.NET / ASP.NET MVC application based on ELMAH. I showed some basics features as well easiness of ELMAH integration to ASP.NET MVC with ELMAH.MVC NuGet package. It was very light and funny talk, especially discussing Troy Hunt's ELMAH attack.

I also really much enjoyed Anton Samarskyy talk on jQuery deffered objects and Vitaly Koval did great hacking session of WinRT.

I some of you been listening to me on those speeches and still have any questions or concerns, feel free to contact me by comments or through twitter. See you next time!

Foundation Framework for Web Sites Production

2012-02-21T11:15:00.001+02:00

The Foundation framework is something I discovered by accident browsing through some github project pages. I really liked how one of the sites looked on my iPad. I was also pleased to see how HTML crafted, using clear names for classes and HTML5 semantics. As it turned out, that site was using Foundation Framework by Zurb - design agency in San Francisco Bay area.

I checked out the documentation and Foundation appears to be pretty solid framework for web applications prototyping and production. It contained everything needed: Grid Layouts, Buttons, Forms and UI. And of cause, all of that is open source hosted on github.

During my preparation of project page for candidate I decided to try it out. I was really happy of the experience.

Object Oriented CSS

Have you heard of OOCSS? Initially I thought that idea is almost non-sense, but I'm changing my opinion now. I think Foundation fully conforms to OOCSS style of development - each behavior or UI you want to apply to HTML element is done by applying of corresponding class.

Great thing is that you see how it's done in framework and do same in your code as well. I remember the times I started to do HTML/CSS and I higly used #id's, applying the styles by element Id. The code was awful and styles applied on #id's were not re-usable at all, so if I needed the same margin/padding or text color I have to copy the section of CSS and move it into next #some-id { ... }.

With OOCSS you rely on classed. Here some example,

<div class="container darker-grey light-border small-padding">
 <div class="row smaller-fonts">
  <div class="four columns"></div>
  <div class="four columns"></div>
  <div class="four columns"></div>
 </div>
</div>

Look, no #id's - classes only. With classes I control: position, colors, borders and margin/paddings. This is really cool, since all of that classes are easy reusable in any part of page.

Grid system

Grid systems is really cool concept and allows to develop much faster. Instead of writing own CSS that would position elements, you stick to Grid System. The classical grid system is probably 960.gs. It's really great and blown my mind as I first time tried it, but currently it little outdated: 960px wide is small for modern monitor and it is not adaptive. Modern web design demands site looks great both on PC and Mobile devices, adapt it's content based on screen size.

Here is a quote of Foundation documentation.

The grid is built around three key elements: containers, rows, and columns. Containers create base padding for the page; rows create a max-width and contain the columns; and columns create the final structure. Everything on your page that you don't give a specific structural style to should be within a container, row and column.

You develop the layout based on planned number of row and columns that compose the row. Again, code is done in OOCSS way with clean classes names, so you write almost "plain" English in HTML.

<div class="container">
  <div class="row">
    <div class="eight columns">
      Eight columns
    </div>
    <div class="four columns">
      Four columns     
    </div>
  </div>
</div>

After design is ready, you just open it on iPad and.. Surprise, it looks great there! Text and columns are adaptively fits the screen size.

Buttons and Forms

Buttons and Forms are same important as Colors and Fonts in your web site. You can't get good site appearance if buttons and forms are ugly. I usually spend a lot of time on "beautifying" those, but still unhappy with results at the end of the day. With Foundation it's easier. You got nice styles from the box.

Forms:

Buttons:

Recently, I've submitted green button style, so I hope it will be available soon.

UI stuff

Besides those primary things you got nice bonus. That's different UI elements commonly used through different web sites. It includes: Alerts, Labels, Warnings, Tooltips, Tabs etc.

For candidate site I successfully used Pagination UI element.

Conclusions

Currently Bootstrap from Twitter is obvious leader in that niche. But I really think Foundation will get it's place. Easy to use, great documentation repository is very active, so we might expected further great features in Foundation.

And by the way.. To payback Foundation, I got idea for small product: inspired by Bootswatch I'm about to create bunch of "ready-to-use" Foundation themes, that you just download and start to use immediately. It will work great for people who are about to create one page product presentation or simple blog. Hope it will go fine and I release it soon.

Candidate v.0.0.1rc - Released

2012-02-14T07:37:00.000+02:00

You may notice that I stick to original project name at the end of the day, even thought I wish to change it. That happened for 2 reasons: first, I really get used to candidate and it's good enough project name.. second, I spent some hours of brainstorming but found out nothing better that existing.

This weekend I also finally concluded project web site and hosted it as github pages - http://alexanderbeletsky.github.com/candidate/. So, ladies and gentlemen - please welcome, Candidate v0.0.1rc is ready to be shown to the world.

What's the goal?

Thinking about nearest "competitors" in this area I would re-call Octopus by Paul Stovell. Octopus uses Build Server / Tentacle (Agent) architecture principal, while Candidate is simple Agent architecture - you host it the same machine as your environment is (stage, production) providing both integration and deployment functionality.

My goal is stabilize and improve Candidate through this year, so it fulfill different requirements including performance and scalability. I switched all my projects to use Candidate now, so it would give me some initial feedback.

Nevertheless, Candidate may turn out to be a powerful deployment application I'm still thinking about "Deployement as Service" product like AppHabor and Heroku or Travis-CI as it was original idea.

What's next?

Following the principle "Build product X to learn technology Y" I'm going to proceed with Candidate to shape following areas that I wish to improve now:

Processes, threads, synchronization in .NET
Async, Tasks library
Robust applications architecture
Different deployment scenarios for .NET platform

Technological stack is still ASP.NET MVC3 / C#/ jQuery. Currently application requires to be hosted on IIS, with application pool Process Identity equals to Admin. This does not suite all users. So, I'm looking forward to create self-hosted version using NancyFX.

I also try to target UI / UX issues as much as possible.

Wanna join?

I would be happy to. I'll much encourage you to download application, install it, perform simple testing (scenario could be found here). Let me know what you think, that would be great initial contribution. As for any github hosted project, you are absolutely free to fork, hack it out and send pull request.

Thanks for you help.

Few Things I Learned From IdeaStrike Project

2012-02-09T20:20:00.000+02:00

First of all, I have to say Code52 team is doing just amazing job. It's very original initiative, cool ideas and highly productive team. Each time they announce next thing to build I have "product envy" inside me. Check out their blog or github account to be updated.

My attention this time was attracted by IdeaStrike project. It suppose to be analog of uservoice for OS community. As always, first release was very fast and I was very curious what's inside. So, I cloned the repo and did small hacker session. I've spend some hours with it and would like to share some initial thoughts.

Build script is small and clean

Project contains build.cmd as I run it downloaded all dependencies by NuGet, build web site and run all unit test. Basically, all you need for any small project. Then I looked inside, it turns out like:

@echo Off
set config=%1
if "%config%" == "" (
   set config=Debug
)

%WINDIR%\Microsoft.NET\Framework\v4.0.30319\msbuild build.proj /p:Configuration="%config%" /t:AppHarbor /m /v:M /fl /flp:LogFile=msbuild.log;Verbosity=Normal /nr:false

At the time I first looked in it also contained small script for running tests, but later they moved that to .csproj as separate target.

Use NuGet without committing to SCM

I was amazed, how fast git repository was cloned and as I checked out packages folder with all dependencies were just empty. How can it be? As I said in #1 as I run build script they just automatically downloaded for me. As it turns out, this is feature of NuGet that allows to work with dependencies, without real necessity of committing those to SCM. This is very cool, especially if you have big project, so cloning and branching appears to be prolonged operations. The implementation details is on nuget site.

Deploy application DB at first launch

IdeaStrike is based on EF 4.3 Beta 1 currently, using Code First approach. EF Code First also includes very cool feature called Migrations. This is something I really lack first time I tried EF Code First approach. You define the Context, DbConfiguration class and migration scripts (that's also, just a C# code), so at application bootstrap you call the code like:

private static void DoMigrations()
{
    var settings = new IdeastrikeDbConfiguration();
    var migrator = new DbMigrator(settings);
    migrator.Update();
}

The database and schema will be automatically deployed on first application run.

Social login with Janrain

As I clicked to Sign In button, I've been showed nice dialog to select my existing social account to login.

JanRain is very cool solution. I remember I tried to investigate something like that for ASP.NET MVC and was really disappointed, because I actually found nothing. For all of existing solutions you have to read OAuth spec and write own code. JanRain does all dirty job for you. As user authorized you receive POST on given URL, with a special token. By given token you request the details about the user, like name and email and so on (see LoginModule.cs). It has fair plans for hobby projects and bloggers.

Bootstrap your CSS and HTML

Bootstrap neither new nor very unique, at least I know several good CSS/HTML frameworks. But IdeaStrike proved one more time - it has no sense to invent the wheel. Take advantage of results produced by people who are smarter than you, that's the rule of pragmatic programmer.

Dear future me, please never ever again start your application with HTML/CSS from scratch, you can build nothing more as shit. Bootstrap is great for different kind of projects and prototypes. Taking into account number of watches and forks on github I expect even more improvements and features in future.

Nancy as web framework

I've heard about Nancy many times, but it's only now I got a change to touch it. For me it's just alternative reality comparing to ASP.NET MVC. It is not hard to understand what the code does. It is not hard to apply changes there. You are very explicit of what you are doing, by specifying HTTP verb, route and action as lambda. First class citizen in Nancy is Module, all module's logic is placed inside the constructor:

public FeatureModule(IIdeaRepository ideas, IFeatureRepository features, IUserRepository users)
    : base("/idea")
{
    _ideas = ideas;
    _features = features;

    this.RequiresAuthentication();

    Post["/{idea}/feature"] = _ =>
    {
        int id = _.Idea;
        var feature = new Feature
                        {
                            Time = DateTime.UtcNow,
                            Text = Request.Form.feature,
                            User = Context.GetCurrentUser(users)
                        };
        _features.Add(id, feature);

        return Response.AsRedirect(string.Format("/idea/{0}#{1}", id, feature.Id));
    };
}

Nancy application could be hosted as ASP.NET / WCF / Self hosted runtimes, it supports different View Engines (including Razor). In short, it is great ALT.NET tool and will find a lot of applications in different projects. More details on Nancy github account.

Conclusions

IdeaStrike is great example of open source project you can learn something from. I would not say I got only positive impressions, moreover there are some obstacles that block me from my normal development flow. I'll try to share my observations on next blog posts.

NancyFX, probably be my next web framework to learn, since I need to move out of ASP.NET MVC which is comfortable zone for me now. I'll be keep looking for IdeaStrike and hope to do some pull requests as well.

New Tools in My TDD Arsenal

2012-02-02T11:36:00.000+02:00

Recently my TDD arsenal has been enhanced with 3 new cool tools, which I'm about to share with you. More precisely it one tool and two frameworks. Let's go for it.

NCrunch

NCrunch is just amazing extension for Visual Studio created by @remcomulder. It automatically detects all your tests and re-running those as soon as source code changes happen. Forget about manual test re-running, it's just waste of time. You even do not need to press Ctrl + S, just continue coding as you usually do.

Initially I had big doubts about such kind of tools, but NCrunch changed my mind. It supports major unit test frameworks NUnit, XUnit, MSpec etc. Besides of that it allows to collect code coverage metrics (and show it just in VS editor), run tests under debugger, supports multi-core systems etc.

In short, NCruch is something that makes your TDD very smooth, allowing to focusing on important things and forgot about some routine.

NSubstitute

I stick to Moq for quite awhile and saw no reason to switch it.. Till I saw NSubsitute. I hardly could imagine someone who staring "yet another mocking framework project", it looks like absolute non-sense.. But those guys proves me wrong.

Well, what's so new there? First of all it have very clean API. No more new Mock() or MockGenerator.GenerateMock(), creation of test doubles are nothing more as Substitute.For<IEntityToMock>(). Mocking properties, multiple return values, events etc. in very easy fashion. Check out their getting started materials for further info.

Best feature as for me, that by using extension methods they got rid of lambdas for setting up mocks. It makes test code more readable and clean. See this small gist there I placed just some Moq and NSubstitue tests together.

I would not say that Rhino or Moq is now much worse that NSubstitute.. No, I would just say NSubstitute is a little better. Even same functionality, with less amount of code is already big argument for me.

[Test]
public void should_send_an_email_if_users_signs_up_nsub()
{ 
 // arrange
 var emailService = Substitute.For<IEMailService>();
 var controller = new LoginController(emailService);

 // act
 controller.SignUp(new SignUpModel { Email = "a@a.com", Password = "xxx" });

 // assert
 emailService.Received().SendEmail(Arg.Any<EmailMessage>(), "current");
}

FluentAssertions

Again, for years I followed classic NUnit's Assert.That() method. I also played a bit with SharpTestsEx, but FluentAssertions by @ddoomen is going to change that.

FluentAssertions are based on extension methods and allows you to get rid of Assert.That call and just wrote your assertion directly to object. Here some example:

{
    // NUnit.Assert style..
    Assert.That(result, Is.EqualTo(3));

    // FluentAssert style..
    result.Should().Be(3);
}

This is very simple example. The power of FluentAssertions arise then you need to have either multiple assertions or assertions on complex objects. Multiple assertion could be combined by And, like:

{
    "somestring".Should().Contain("some").And.HaveLength(10);
}

It also provides great support for working with Collections, DateTimes, Guids, Exceptions, XML etc. Project is hosted on codeplex, here is documentation. Easy start, easy go.

Conclusions

Now, I'm sharpening my axe on those tools and have very nice impressions so far. Special thanks goes to @skalinets who introduced me with those tools.

Agile Base Camp 2012

2012-01-30T20:54:00.000+02:00

Past Saturday I was a part of big Ukrainian event Agile Base Camp: From Idea to Product. It's been organized by ScrumGuides, pioneers on Agile in Ukraine and organizers of famous Agilee series of conferences.

The conference named "From Idea to Product" and focused on product development issues. There was 3 stages there: Main, XP, UX. Main is for more or less common topics as budgeting, motivation etc.. XP is practical stage for developers and UX for user experience engineers. The program of conference was really interesting, but I spend all my day on XP stage (no surprise).

There were great speeches by Dmytro Mindra, Sergey Kalinets. Probably most valuable for me were ones by Vitaliy Stakhov and Anatoly Kolesnik, Vitaliy shared Hypermedia concepts of RESTfull systems and that looks very promising. Anatoly did great NoSQL introduction that is very actual at the moment. I also enjoyed Dmitry Efimenko speech about testing in product company. He did it in quite tough style, so crowd was a little shocked and kept silence till the last words. I got some interesting points for myself.

I did a talk about - Continues Delivery / Deployment / Production. This practical field is very interesting to me not only because I'm trying to build a product for that and I want to adapt for all project I work to.

I've got very nice feedback and questions after my speech, totally collected 15 donuts (a special cards that listeners give to speaker if they like the speech), so I was quite happy about. If you interested, here is my slides on speaker deck.

I really much enjoyed after party and evening we spent in Work'N'Roll, the co-working office of ScrumGuides. Appreciate organizers for that job and wish you good luck of all next events.