It all started with collaboration

Honestly, I am not sure what’s the main reason for writing excessive documentation but I can imagine it has something to do with collaboration. As soon as you start collaborating with people lacking domain knowledge (stakeholders on distance, new team members, third parties etc.) you will find yourself explaining a lot of things, a lot of times.

The quality receipt

There has always been projects where the stakeholder wants a quality receipt. So testers started to specify everything. When a project was finished, the stakeholder had evidence in the form of documentation that this project is something and this something works according to the documents. As you see, this proves very little about the actual quality of the project. Nonetheless it was (and still is) regarded as a kind of quality receipt.

The problem with saying test documentation is a receipt is that it isn’t. The only thing test documentation is, is documentation about testing.

Testing

Testers will not prove quality because there are no really good metrics for quality in its whole. If you start to think about what quality is and how you measure it you will find that it is subjective and emotionally valued and therefore not measurable by anyone else than yourself and by doing that you will only measure your definition of quality.

This is a problem in other environments than software development as well. So, what can we do as testers? We talk to our stakeholder and use our experience to find out which quality characteristics are more important (this to assure that we spend time testing the right things). Then we decide restrictions in which the system must be kept.

With restrictions defined we can perform and analyze test activities for how well the system meets these restrictions. This way we can get some results and communicate our analysis to the stakeholder.

A word on releases

In some companies, the testers are the ones with power to say "go" / "no-go" for a project release. Doing this, the stakeholder will definitely expect a receipt of quality. If any bug shows up it will be the testers responsibility and the stakeholder will be less involved in the project. A loose-loose situation, one could say.

Ideally the product owner should be the one that makes release decisions, based on a recommendation from the development team. There are many business decisions that needs to be taken into account when releasing a system. It’s not all about quality you know!

The testers responsibility is testing things, this involves all surrounding activities (planning, analyzing, reporting/communication etc.). The core responsibility for a tester should be to provide enough data from the tests of the system for the stakeholder to feel confident enough deciding on releasing the system.

Communication

Sometimes there is a demand from the stakeholder for extensive documentation. Listen to your stakeholder and see if you can provide the documentation he needs but at the same time pay attention and try to find out the root cause for the need of more documentation.

If you find out the root cause it might be cheaper to fix it than spend unnecessary time writing test documentation. A good start could be to communicate more with your stakeholder. When communicating you will start a relationship and with this relationship the stakeholder starts to feel more relaxed about your questions. This communication also opens a feedback gate which, once opened, will provide you with immense knowledge about what quality criteria is more important to the stakeholder.

Easier documentation

So here is my solution to test documentation in Agile projects. I will show you an easy way of documenting what has been tested, when and how.

Enter the matrix:
Testplan
This spreadsheet is quite simple. It communicates which test-activities has been performed on which date.

Now let’s take a look at another one:
Testmatrix
This spreadsheet communicates information on another level. Here we can see which requirements have been tested on which dates and which focus area the tests had.

To utilize the full potential of the documents, they have to have the dates synchronized. This way you can always go back and see what happened when. In combination these two documents covers most necessary documentation needs. You can see what has been tested when and how and the level of detail is of course something you can adjust.

The most efficient way according to me, is to let it be dynamic documents, updated after each activity has been performed. This way the information in the documents always matches what actually happened in the sprint and you will be able to analyze the documentation to improve your test planning.

Summary

Using these spreadsheets and complementing them with log results, bugs and other required information, you have a basic test report. Finish off the report with some descriptive text regarding the test activities and test results in order to make the report more readable for the stakeholder and there you go. Lightweight agile test documentation with high readability and minimal production time, a way of making test documentation easy in Agile projects.

Surprise #1, Add-ins

I had quite low expectations on what storage alternative that would be available - "a SQL Server service, a key/value store and perhaps a queue" was what I thought. The first thing that surprised me was that App Harbor has as many add-ins as Heroku (I didn't count though) and I could choose between SQL Server, Couch, Mongo, Redis and RavenDB - all free in the most basic setting (i.e. small storage, no backup, etc). I turns out that RavenDB was added to the add-in stack quite recently. Cool.

Surprise #2, Learning RavenDB is easy

I added the RavenDB add-in to my app with a click and on its configuration page I saw both a link to the Silverlight administration tool and a url to the database. For about a year ago, I wanted to play with RavenDB at home, so I installed it on my personal machine but I couldn't make it work. That is my personal experience with RavenDB, even if many colleuages and people in the community have praised it.

I wanted to drive my learning with small tests and thus created an empty project in Visual Studio. First I had to add RavenDB (client) and NUnit to the project, using NuGet. Then I went back to AppHarbor and clicked the RavenDB admin link, installed Silverlight, and RavenDB then asked me if I wanted it to add some sample data to my database, since it was empty, which I did.

After that I could easily find a "getting started" page with how to insert data into RavenDB, copy/paste that code into a test, replace the URL and run the test. It didn't work...

It turns out that the URL and API key was separated with a semi-colon, which took me 2-3 minutes to figure out. DocumentStore has a property APIKey, so I set the API key there instead of having it in the URL and ran the test again. The test did not crash and a document appeared in the RavenDB admin application - success.

Move code to controller

I now had some test code that worked on my local machine that talked to a RavenDB database instance on App Harbor. The next step was to create a new ASP.NET MVC 4 project, move my test code to a controller action (nothing fancy, adding a redirect at the end of the code I already had) and run the proect. I clicked on a link to my controller action and again saw in the RavenDB admin app that a new document had been created, which was what I had expected. Nice.

Deploy

Now, I wanted to deploy my working code to App Harbor. Following the instructions, all I had to do was to add a .gitignore file to the application's root folder, and run the following commands

git init
git add .
git commit -m "Initial commit"
git remote add appharbor [my repo url ]
git push appharbor master

I then opened up my app's admin page in App Harbor, followed the link to my app and it worked just as on my local machine, as I expected.

Finally, I wanted to add some form of query from the database. The simplest kind of query is a Count(), so on the index page I added some code to show that. Now, each time I clicked the link, the counter was incremented with one - I did no longer need to go to the RavenDB admin app to see if a new document had been created.

Summary

App Harbor was very easy to get started with. It has many add-ins, including RavenDB. I thought it was easy to start using the RavenDB add-in: I could test the API from my local machine and then move the working code to a web project. Deploying to App Harbor with git is also very easy.

The three things you should know about Server-Sent Events are: It's..

• uni-directional (only server push, initiated by client)
• using pure HTTP
• not using polling

The uni-directional constraint is not a problem, since the client still can GET data from the server or POST messages to the server, using XMLHttpRequest. Instead, let's focus on the other two...

Pure HTTP

This feature is golden, because it has a lot of nice implications. First, even if SSE is not supported by all browsers, the fallback is just to start to use polling (polyfills for SSE are found here). Second, the integration story for other types of clients than browsers is better than websockets - no need for an websocket implementation on the client to be able to consume the events, just use HTTP. Third, it's not an "all-or-nothing" approach like websockets - you can start with a naive server implementation and gradually improve it. I will explain this last statement in more detail below.

It's not polling

Searching the web, it's not a problem to find out how the data format for SSE looks like. I recommend to read the last part of section 7 of the specification for more details. However, it's not clear how the connection between the client and the server is working. At first, I thought I just had bad luck in searching the net, but now I realize why there was not a single answer on how to think about the client/server connection. The answer? There is not one right answer, but rather several right answers, depending on your requirements.

First, let's look at a sequence diagram using as much of SSE's promises as possible. (The image is a link to a larger version)

In the diagram, we see that a connection is kept open as long as possible by the client/server pair and when the connection is closed (i.e. by a router, proxy, firewall, etc) the client reconnects to the server. As Damien Edward says on the excellent Hanselminutes episode about realtime web (I'm paraphrasing): SSE is similar to the long polling strategy, except that the connection is kept open as long as possible.

Begin simple

Keeping a connection opened as long as possible? That doesn't scale! Yes and no. As Damien Edwards mentions in the Hanselminutes episode, in classical usage of ASP.NET this would be a problem, since every connection has a thread in the thread pool. If performance becomes a problem, one can refactor towards an asynchronous model, à la Node.js, which would reduce the memory footprint. But not every developer groks asynchronous design well, so there's cost involved here as well. Of course, it depends a lot on your specific scenario, YMMV.

But there exists a still simpler solution: instead of keeping the connection open you can close it when you consider yourself done.

"Ahaha, that's polling!" Yep, it is, and it's very simple to implement and understand. And it has some potential problems, of course, but it all depends on what your scenario is. Perhaps it's a sufficient design to use polling, both for user experience and performance?

A cool thing with SSE is that you can perform these refactorings on the server-side without changing the client side. "Upgrading" websockets in a similar way is not possible - either you use a websocket connection or you don't. But then, if you know that [parts of] your web app is going to need "as much realtime as possible" and is expected to be used by many users at the same time, go for websockets.

There's also an interesting possibility to use a more heterogeneous architectural style and use SSE on some parts of the app and websockets on other parts, depending on the scenarios and requirements.

Summary

Server-Sent Events is an interesting light-weight and refactoring friendly alternative to websockets and is worth investigating. It has a good 3rd party integration compared to websockets since SSE is using plain HTTP. And SSE is uni-directional, so the client needs to use XMLHttpRequest to communicate client-to-server.

Resources

W3C EventSource/Server-Sent Events Specification
http://www.w3.org/TR/eventsource/

When can I use Server-sent DOM events?
http://caniuse.com/eventsource

Damian Edwards explains The Realtime Web for ASP.NET with SignalR (audio podcast, recommended)
http://hanselminutes.com/291/damian-edwards-explains-the-realtime-web-for-aspnet-with-signalr

Real Time Rack (video presentation, recommended, start from 22:50 for non-Ruby content)

http://confreaks.com/videos/727-rockymtnruby2011-real-time-rack

HTML5 Rocks: Stream Updates with Server-Sent Events
http://www.html5rocks.com/en/tutorials/eventsource/basics/

Aslak Hellesøy compares WebSockets and Server-Sent Events and concludes that SSE have a better application-to-application integration story
https://github.com/aslakhellesoy/webbit-rest/wiki/Chat-Room-Example

StackOverflow: WebSockets vs. Server-Sent events/EventSource
http://stackoverflow.com/questions/5195452/websockets-vs-server-sent-events-eventsource

StackOverflow: What so different about Node.js's event-driven? Can't we do that in ASP.NET's HttpAsyncHandler?
http://stackoverflow.com/questions/5599024/what-so-different-about-node-jss-event-driven-cant-we-do-that-in-asp-nets-ht

Jim Webber's opinion about websockets
https://twitter.com/#!/jimwebber/status/172748058336034816

InfoQ: WebSockets versus REST
http://www.infoq.com/news/2012/02/websockets-rest

I was reading Tomas Petricek's and Jon Skeet's book Real-World Functional Programming which contains a short section about point-free style. The conclusion was that the code could end up being hard to read. However, I found the examples in the book quite elegant and was intrigued to learn more.

Point-free style originates from a mathematical branch called topology which deals with spaces composed by points (values) and functions between those spaces. A function is said to be point-free if it doesn't mention the points of the space which it operates on. In functional programming this translates to a function that doesn't mention the arguments of its transform. The point (no pun...) is to make the code less verbose and to focus more on behavior of the function than on its data.

In order to accomplish point-free style, functional programming features such as higher-order functions, function composition and partial function application are used. Let's look at some examples:

let rec sum list =
   match list with
   | [] -> 0;
   | h::t -> h + sum t

This function sums the elements of a list recursively. Since the arguments are bound in a pattern matching expression they can't be taken out so we need to rewrite it using a higher order function like so:

let sum list = List.fold (+) 0 list

The fold function takes an aggregating function, a seed value and a list as arguments (note that the +-operator is surrounded by parentheses which turns it into a function). The function's type signature is:

val sum : int list -> int

That is, it's a function taking a list of integers and returning an integer value.
Now, if we remove the list argument we get:

let sum = List.fold (+) 0

and the type signature:

val sum : (int list -> int)

The signature is the same but surrounded by parentheses which means that the sum function returns a function instead of a value, i.e. it's a partial function application. Since the signature is the same as previously the usage is the same e.g.

let addingNumbersOneToTen = sum [1..10]

Here's another example:

let add10To list = List.map(fun x -> x + 10) list

The map function applies the given function to each element of the passed list. In this case, a lambda function is used for adding 10 to each element. Using a partial function application instead of the lambda we get:

let add10To list = List.map((+) 10) list

and without the list argument:

let add10To = List.map((+) 10)

which is completely point-free.

Finally an example of using function composition to obtain point-freedom:

let doubleAndIncr = fun x -> x * 2 + 1

This function, as the name implies, doubles the given value and increments it with one.
Composing the multiply function and the add function will get rid of the lambda function:

let doubleAndIncr x = ((*) 2 >> (+) 1) x

and making it a partial function application will loose the x argument:

let doubleAndIncr = (*) 2 >> (+) 1

I think point-free style can make the code more readable when used wisely. As in the last example above the expression to the right reads almost like natural language "times 2 and then plus 1". Of course, it could get really gory but so can anything else in the world of programming.

Refs.
Tacit programming
HaskellWiki
Point-free style: What is it good for?

The idea of this last post in the series is to look back and discuss what we had done differently building the Windows Phone app, knowing what we know now.

This post is a part in a series - you can find the full index here.

Isolate 3rd party libraries

Yes, we know – there are lots of great frameworks out there. Yes, we know – the wheel should not be reinvented over and over. So, to be clear, we are not against 3rd party libraries on Windows Phone. But before adding that library reference through nuget, there are a few things to consider.

• Does it solve a problem in a smarter way than something I would be able to create in matter of hours?
• Do I have full control over the impact on performance?
• Can I jump to Windows 8 and find the same component or rewrite my code easily?
• Can I isolate the component or will it scatter across my code base?

We had a couple of 3rd party components in the Reseguiden Windows Phone application. We removed them all when converting to Windows 8. Silverlight Toolkit was easy since it was only used by the views, and they were removed in the conversion as well. We only used a fraction of Caliburn.Micro so that was easily removed and rewritten. The big hit came when all JSON parsing had to be rewritten to replace ServiceStack.Text.

So, the big lesson learned here is, if you are to use 3rd party libraries, make sure they are isolated. It will help when converting to Windows 8, and will surely help in other situations as well.

Isolate navigation

Yepp, navigation has changed. From working with Uri’s and query strings to navigate and pass data, Windows 8 instead uses types and objects.

The advantage of the new way of navigating is that you don’t have to deal with a bunch of strings. The drawback is that you have completely rewrite your navigation handling. In other words, if you have spread out the navigation code throughout your code base you have quite a task at hand. Luckily for us, we had all navigation logic in one class. Replacing that class with a Windows 8 version was done in minutes.

Isolate storage

(no pun intended )

Of course there are way to store data locally both on Windows Phone and Windows 8. One difference though is that Windows 8 also has both temporary and roaming storage. Another difference is that also storage has moved from .NET to WinRT.

What we’re leaning towards here is that you win a lot by isolating your storage behind and interface, or at least keep everything in one class. The storage code has to be rewritten anyway when converting to Windows 8, so if it’s tucked away in one single place it won’t interfere with your other code.

We also mentioned the temporary storage in Windows 8 – a cache. Windows Phone does not separate temporary storage from storage. But doing this separation yourself logically in your Windows Phone app, even though it eventually is stored in the same storage, will help you when going to Windows 8.

MVVM

To be hones, we cannot say what this conversion would have been like without view models, we haven’t tried it. We haven’t tried converting an app with a lot of code and logic in the xaml.cs code behind files. We also haven’t tried converting where text formatting is done in the view instead of the view model.

We are glad we haven’t.

Will you be able to use your view models right off the bat? Well, since the views in Windows 8 probably will look a bit different that on Windows Phone the view models will not fit perfectly. But as a starting point they are really nice to have. It was quick for us to make the small modifications needed for the view models to fit our Windows 8 views.

To try to share view models completely between Windows Phone and Windows 8 will probably be counterproductive. A view model is there to serve a specific view and serve data in the exact way that view wants it in. Since the views will be different (they should be different) the view models will be different. Hence forcing the use of the same view models will make them unnecessarily complex.

Localization

The use of resource files differ between Windows Phone and Windows 8. To make the transition as smooth as possible, we recommend naming your resource keys according to the Windows 8 convention (Uid.Property, e.g. LoginButton.Content) also in your Windows Phone application. If you in addition to this bind to your resources directly in your views, all you have to do in your Windows 8 application is to copy the strings to a new resource file.

So, even if it’s not reusable as-is, also the localization can be transferred pretty smoothly.

Data bind ApplicationBar

In Windows Phone there is, as we all know, an application bar. What we also know, to everyone’s frustration, is that you cannot data bind directly to it. You have been limited to three options:

1. Create it in XAML
2. Create it in code
3. Write a wrapper and data bind to that

Our advice is – write a wrapper. Why?

The application bar in Windows 8 can be data bound against. So if you’ve chosen option number 1 or 2, you all of a sudden have some code to rewrite. (yes, XAML is code too). But if you’ve gone for option 3, you can simply bind your view model to your application bar in Windows 8 instead of Windows Phone and your done.

Conclusion

Altogether this conversion took 3 days and honestly speaking, the biggest hurdle was Visual Studio 11 Beta and Resharper Beta. The conversion itself actually was pretty frictionless. Worth mentioning is;

• We did not do a full conversion – we only chose a subset of the functionality and got that to work
• The application we started with is small – only six views in total

If we instead had chosen to convert one of the larger apps we’re working on (40+ views) this article series would probably have been a tad bit longer…

The goal has from the beginning been to take a real world application and see what kind of problems we run into. We have run into problems, but nothing that we haven’t been able to solve. We would like to end this series with some thoughts on the future.’

One might speculate… that there is a new version of Windows Phone in the future

One might speculate… that it will build on the same kernel as Windows 8

One might also ponder whether the right way to go is to separate the code bases today and migrate back from Windows 8 to Windows Phone 8 in the future. We think so.

In this blog I will give you an overview of Neo4j.rb.

Neo4j.rb - a New Type of Object Database ?

Graph and object databases (ODBMS) have many similar advantages. They are both good choices for data containing many relationships and composite objects. It's natural to map objects in an object oriented programming language to nodes,properties and relationships in a graph. That means you can use a graph database like it was an object database. For example, instead of using a database schema you can specify the structure of the graph database by using Ruby classes. You can also visualize the graph database in order to understand how your objects are related by simply following relationships between nodes.

Another reason for choosing a graph database is for solving graph related problems like finding critical paths in projects, implementing spatial algorithms or route planning. Some of these problems are impossible to solve using a different type of database. In this blog I will show how the graph database Neo4j can be used to implement a recommendation algorithm as well as using it like an object database for creating complex domain models.

The first question to ask before using Neo4j is which flavour of Neo4j you want - the embedded or the standalone server version ?

Embedded or Server Neo4j ?

There are two different ways of using Neo4j - as a standalone database with a REST protocol or using it as an embedded database with a programmatic API.

Some of the advantages of using it as a standalone database is that it’s possible to use it from any language and multiple clients that can talk REST (for example see the neography gem). It is also available on Heroku as an addon. In this blog we are going to use the “unplugged” embedded Neo4j version which only can be used from JRuby.

The advantage of the embedded Neo4j is better performance due to the direct use of the Java API. This means you can write queries in plain Ruby! Another advantage of the embedded Neo4j is that since it’s an embedded database there is one less piece of infrastructure (the database server) to install. The embedded database is running in the same process as your (Rails) application. Since JRuby has real threads there is no need to start up several instances of the database or of the Ruby runtime since JRuby can utilize all available cores on the CPU. There is actually even no need to start the database at all as it will be started automatically when needed. Notice it’s still possible to use the REST protocol or the web admin interface from an embedded Neo4j, see the neo4j-admin gem.

So which should I choose ? Well, if you can’t use JRuby or you don’t need an Active Model compliant Neo4j binding then the Neo4j Server is a good choice, otherwise I would suggest using the embedded Neo4j.rb gem (but I’m a bit biased )

Installation of Neo4j.rb

Before installing Neo4j make sure you have installed JRuby. The easiest way to install JRuby is using RVM. Neo4j.rb has bin split up into three gems: neo4j-core, neo4j-wrapper and neo4j. In this example we are only going to use node, relationships and properties which mean that it's enought to install the neo4j-core gem.

gem install neo4j-core


You have now installed both the JRuby binding to the Java API and the embedded Neo4j database.

Node, Properties and Relationships

The basic building blocks of a graph database are node, properties relationships instead of tables and columns.

Now, open an IRB session and lets create two nodes:

All modification to the database must be wrapped in transactions. Neo4j supports ACID transactions. Both nodes and relationship can have properties. Neo4j is schema free. That means that you do not predefine types and relationships. You can at any time change a property from one type to a different type. Example of setting properties on a node:

In a graph database, relationships are first class citizens. (By the way, I like this tweet:
"With neo4j it is the relationships, not the data, that count"). Relationships in Neo4j have a type and a direction. Lets create an outgoing relationship from node alice to node bob of type friends with one property.

We have now created the following graph:

To retrieve all outgoing nodes of type friends from node alice of depth one:
alice.outgoing(:friends)

To navigate the same relationship type but in the opposite direction:
bob.incoming(:friends)

There are many more methods for doing advanced traversals of relationships of any depth.

An Example of a  Recommendation Algorithm

By using the traversal methods it is easy to solve problems like finding recommendations. Here is a very simple implementation of finding recommendations for twitter users. It compares similarities in tags used in tweets. Let say we have the following users which have tweeted using the tags #neo4j, #jruby and #rails.

A Database Model for Twitter Users

We now want to recommend Alice a new user to follow, based on similarities in hash tags. Here is a rather naive algorithm. Lets first find all users who have used the same tag as Alice. We do that by traversing outgoing used_tags and incoming used_tags. We stop at depth two and find users Ted, Bob and Carol. Since Alice already follows Ted we exclude him. For all these users we find which tags they have used and compare that with Alice’s tags. Since Alice and Bob both have used tags #neo4j and #rails and Carol and Alice only have #rails in common we then recommend Alice to follow user Bob.

A complete Rails example using this algorithm can be found here. It’s often both easier and faster to use the declarative cypher query language -  a SQL-like language for graph matching.

Here is an example of using the new Cypher DSL support in Neo4j.rb 2.0 using the same algorithm.

You can play around with the generated cypher query here using the Neo4j REPL console. Another alternative is using the excellent pacer gem.

Performance Benefits of Neo4j

Neo4j is optimized for fast traversals of the graph by navigating in and outgoing relationships. The performance of Neo4j will remain the same independently of data size and the depth of traversals. This is a huge advantage over relational database (RDBMS) where the data size and the number of join operations have a strong negative impact on the performance. This is a benefit that both graph databases and object databases share.

How Neo4j Maps to Ruby?

In the example above we have shown how easy and efficient it is to use Neo4j to solve graph related problems. The next thing I want to show is how Neo4j.rb maps to the database. Neo4j.rb consists of a three layers API :

Layer 3 creates a transaction automatically. However, if you need better performance you can always access the unwrapped Neo4j::Node objects. Another reason to use layer 2 or 3 is to declare properties and relationships. This makes it more convenient as Neo4j.rb will generate accessor methods. Using layer 3 also means it works very well together with Rails 3 and many other Rails gems (see for example Rails 3 Scaffolds and Generators or old blog Neo4j 1.0.0 and Rails 3)

Example:

The p.friends method is the same as p.outgoing(:friends). Notice that it’s optional to declare types on properties and relationships.

Example of Domain Modelling

One of the advantages of an object database over RDBMS is the ability to persist composite objects and relationships. Using RDBMS for complex domains can cause an explosion of smaller tables which will degrade the performance because more tables have to be joined. The next example will show how to persist composite objects and data structures using Neo4j.rb. Lets say we want to create a model for the following domain:

A student can enroll in one or more seminars.
A seminar has students and a waiting list for students.

There are many ways to implement this in Neo4j.rb. I’ve chosen to represent the enrollment as a relationship object. The Enrollment object connects the student node to the seminar node. The waiting list can be represented as a linked list of nodes. Here is an example of what the database would look like:

Neo4j Database Model

In the next code example we will create this database. Notice how easy it is to implement a data structure like a linked list in Neo4j. Implementing varying-sized structures for an RDBMS is often very hard.

How about querying a data structure like the linked list above? One very interesting approach is to build a search tree of nodes connected to the nodes in the list. Let’s say you want to find nodes in the list based on a time interval. Instead of simply traversing each node in the list (Neo4j can traverse between 1-2 million hops between nodes per second) you do a search using the tree instead.

Neo4j Database Model - Linked List and a Tree

How about finding the seminar with number 6001? One way of doing that is by using the reference node which can always be found (Neo4j.ref_node). If you create a relationship between the reference node and the seminar node then you can find it. In fact, Neo4j.rb automatically creates class nodes which are connected to the reference node. All instances of a class are automatically linked to the class node. The all method on the Seminar class returns all instances, which can be used like this:


 Seminar.all.find{|seminar| seminar.number == 6001}


Another way of finding the seminar node is to use the Lucene search engine which is included in Neo4j. All that is needed is to declare an index, for example:

You can then use the the Lucene query syntax or a convenient finder method (similar to the Active Record API), for example:

Object Database vs. Graph Database

Does a graph database have the same disadvantages which are often found in object databases?

Conclusions

Are graph databases the right tool for you? In an awful lot of cases - yes. But a RDBMS might be a better choice if you don’t have complex data. A graph database becomes more attractive as the complexity of the data grows. Sometimes you don’t even have a choice if you need to implement things like a recommendation algorithm. I think graph database is a good fit for many different domains and believe it will become more popular as people discover that it’s not just for solving graph related problems or for social networks. There is still a lot more to explore on how best to use a graph database. You are all welcome not only as a user of Neo4j.rb but also as a contributor! Graph databases are the future and Neo4j.rb is one path to it.

My short answer was “I will be at an international conference talking about software testing”. I had my goal all ready clear for me.

When I started at Jayway there were three things that I noticed differentiated Jayway from other companies

1. The competence training
2. The breakfast seminars
3. Oredev

The Training
In many companies they have small number of training opportunities, you may buy a book or if you are lucky you may go a course or if you are best friend with the boss you may go to a conference abroad.

At Jayway we buy books without any hesitation because that is the least expensive training. During my time with Jayway I have been in serveral courses and conferences. Latest course was the “Certified Scrum Master course”. Jayway thought, who is the best in Scrum?

Jeff Sutherland of course. So we let him come to us for a 3 day course in Scrum so that we become certified scrum masters. That is taking competence training seriously.

In every quater we have C-weekend, C for competence. These weekends start on Friday and ends on Saturday lunch. During these weekends we are testing new frameworks and talking about software craftmannaship etc.

So competence training is equally important for Jayway as it is for me.

Breakfast seminars
During each semester Jayway has several seminars. From testing to development, througout agile leading. Next up coming event are Dependency Injection with Andreas Eriksson

Oredev
Oredev www.oredev.org is a conference founded by Jayway. During the past conferences there has been several gurus speaking there. Dan North, Gojko Adzic, Selena Delesie and James Bach are some of the speakers that has made their voice heard in Oredev conference. .NET, Java, Testing and UX is some of the tracks. This conference is all about software development.

My journey
My five and a half years at Jayway has been great. I have been at serveral conference as a delegate and I have meet several notable persons within testing and programming, like James Bach, Micheal Bolton and I had Jeff Sutherland as my Scrum Master teacher. Eating pizza with Chris Patterson is also cool, as is drinking a couple of pints with Dan North

Competence training, has for me always been and will always be important. I like to learn new things and develop myself as a consultant. Jayway is one of its kind, when it comes to competence training. Next weekend we are going to the archipelagos for a code weekend. That weekend we have a theme, the dragon nest. It is simple, during 48 hours you and your team will come up with a product and you shall sell the idea to some investers. If you are lucky, you may end up coding on your project and someone is paying for it.

I started my carrier as a C++ developer and switch carrier to tester at Jayway. As a rookie within testing I got the best start as possible. I started with a small project for green peace, that had a web service that should be tested. During that project I learned my first exploratory testing and wrote my first Ruby script. I had never been coding Ruby before, but with help from both my boss (that gave me the book about Ruby) and developers from other teams within Jayway, I succeed to create a bank simulator.
After that project that was three month long, I had my first breakfast seminar. The seminar were about Exploratory Testing. From there my carrier started as a speaker. I have been in different types of projects; large projects, waterfall projects and good and bad projects.

So in the fall of 2010 I got the opportunity to participate in an Agile project, I toke that oppertunity. This project were my stepping stone to my dreams; standing on the international stage, talking about the software testing.

In the spring of 2011 I applied for a call for paper to “Agile Development Practices” conference in Orlando, FL, USA, and got accepted. I have never been so happy as when I read the e-mail from the conference.

Later on I got accepted to Belgium Testing Days and now I have been at a test conference in Toronto, Canada.

Later on in May I’ll go to London and in June you can meet me in Krakow, Poland at the Agile & Lean conference. Jayway has given me these opportunities that I never would have had in any other consultant firm.

Where do you see yourself in 5 years?

So, the question is, does the same functionality exist in Windows 8? The answer is yes; same same but different.

This post is a part in a series - you can find the full index here.

New times, new APIs

You will recognize the same thinking when looking at background agents for Windows 8 as in Windows Phone. They are declared in the app manifest and kept in a separate project. The big difference is that the control of the background running has been moved from .NET to the Windows Runtime. And since the logic for it has moved the way to call it has changed as well.

So, the plan is to implement a background agent in Windows 8, explain how it works, what we’re doing and how it differs from Windows Phone. Let’s begin.

Setting up the basics

First and foremost we need to activate our background process. We chose to create a class BackgroundTask and on that the method Register.

public class BackgroundTask
{
     public void Register()
     {
          var builder = new BackgroundTaskBuilder();
          builder.Name = "UpdateLiveTile";
          builder.TaskEntryPoint = "Peach.Background.UpdateTile";
          IBackgroundTrigger trigger = new SystemTrigger(SystemTriggerType.InternetAvailable, false);
          builder.SetTrigger(trigger);
          builder.Register();
     }
}

Worth noting here:

• TaskEntryPoint is the full name of the class to be executed. We have not created that class yet. Important is that the class implements IBackgroundTask.
• We’re creating a Trigger, in this case a SystemTrigger. As you can see we’re triggering on InternetAvailable. Other available triggers are:
• TimeTrigger*
• PushNotificationTrigger*
• ControlChannelTrigger*
• MaintenanceTrigger

*) requires the app the be visible on the lock screen

• You can (but we won’t) register an IBackgroundCondition that can e.g. require the user to be active.

We’ll call Register in the OnLaunched method of App.cs.

Now, let’s move on to our app manifest where we have to declare that we are running a background process. We’ll place the following piece of XML inside the Application element.

<Extensions>
     <Extension 

          Category="windows.backgroundTasks" 

          Executable="backgroundTaskHost.exe" 

          EntryPoint="Peach.Background.UpdateTile">
          <BackgroundTasks>
               <Task Type="systemEvent" />
          </BackgroundTasks>
     </Extension>
</Extensions>

Not so much to say about it, this is how it looks.

Implementing the background process

In this case we will update the live tile from the background process. Before we get to code, we have to create the project to hold the background process. You just add a new project to the solution, we chose the name Reseguiden.Background.

Now to the important part. Go to the properties for the project and change Output Type from Class Library to WinMD file. The reason for this is that it’s the Windows Runtime that will execute the code in this project, and WinRT does not understand .NET. Let’s jump to our implementation of IBackgroundTask.

public sealed class UpdateTile : IBackgroundTask
{
      void IBackgroundTask.Run(IBackgroundTaskInstance taskInstance)
      {
            XmlDocument tileXml = TileUpdateManager.GetTemplateContent(TileTemplateType.TileSquareText02);
            XmlNodeList tileTextAttributes = tileXml.GetElementsByTagName("text");
            foreach (var tileTextAttr in tileTextAttributes)
            {
                  tileTextAttr.InnerText = "Någon text";
            }
            var tileNotification = new TileNotification(tileXml);
            TileUpdateManager.CreateTileUpdaterForApplication().Update(tileNotification);
      }
}

As you can see we create a tile update, nothing magic here. Just regular code that will be executed regardless of if the app is suspended or not. Well a little magic there is; the class must be sealed.

Putting it all together

Now to the step that we forgot when implementing this. If the app were to be run now, the WIFI turned off and on again, the tile would not update, and the app would crash without any error messages…

Important part number 2. Add a reference to your WinMD-project (the one containing the implementation of IBackgroundTask) from your application project. That solves the crash problem.

So, as we brushed on earlier, to test your application you can.

1. Start the app
2. Put the app in the background (e.g. go to the home screen)
3. Wait 10-15 seconds (so the app will be suspended)
4. Disconnect the internet
5. Reconnect the internet
6. Look at the tile and watch it update itself

Das ist alles!

First, the code to the finished example is found here: https://github.com/gustafnk/FeedReaderTechDays2012. Some of the old code is still commented out, in order for you to see what changes were made. (Next time I'll create the git repo much earlier, tracking the changes made.)

In our example, we have a page, default.html, which creates a div which is an AppBar control, so it should also be responsible for turning on and off a button in the bar. But this is not the current case, instead all the other JavaScript files controls the AppBar, in the following style:

// Display the app bar but hide the Full View button
var appbar = document.getElementById('appbar');
var appbarCtrl = appbar.winControl;
appbarCtrl.hideCommands(["view"], false);

My goal with this example is to try to take as small steps as possible in the beginning of the refactoring and then, when I get confidence, try to take bigger steps.We first do a little research and see that itemsPage.js and detailsPage.js contains the code above that hides the app bar button named "Full view". The file splitPage.js is the only place which shows the button.

Feedback through the console

First, let's test if we can receive an event and act on it. An event is something that has happened, so we use "past tense" for the name. Also, the name of the event is chosen from the perspective of the source of the event. From this, we choose the name of the event to be "fullViewPossibleChanged" and expect it to contain a boolean as an event argument. To test the eventing support in WinJS, we run the application and type the following in the JavaScript console

WinJS.Application.addEventListener("fullViewPossibleChanged", function (e) { console.log("Hello Jayway"); });

WinJS.Application.queueEvent({type: "fullViewPossibleChanged"})

and the callback fires, which prints "Hello Jayway" in the console. First feedback cycle is complete.

Refactoring, moving "hide"

Blend's Interactive Mode is your friend

We would like to open Blend and run the app in "Interactive mode", which would give us rapid feedback on the code changes, but currently Blend does not support the "right click brings up the app bar" feature out-of-the-box (issue 1.3.3.31). I had some issues getting the proposed fix to work and it seems very unstable at the moment. At the moment, we need to hit F5 in VS everytime we want feedback, but hopefully the bug is changed in future versions of Blend so that we can get feedback "for free". So, in the rest of the post, when I write run/reload, imagine that you just can stay in the Interactive Mode in Blend and see your changes live.

In itemsPage.js, we comment out the following lines and run/reload the app again.

//var appbar = document.getElementById('appbar');
//var appbarCtrl = appbar.winControl;
//appbarCtrl.hideCommands(["view"], false);

The app bar now shows the button, as expected.

We then copy the event registration to default.js and replace the log call with the code for hiding the button.

WinJS.Application.addEventListener("fullViewPossibleChanged", function (e) {
  var appbar = document.getElementById('appbar');
  var appbarCtrl = appbar.winControl;
  appbarCtrl.hideCommands(["view"], false);
});

After that, we add the line for queueing the event in itemsPage.js

//var appbar = document.getElementById('appbar');
//var appbarCtrl = appbar.winControl;
//appbarCtrl.hideCommands(["view"], false);
WinJS.Application.queueEvent({ type: "fullViewPossibleChanged"})

When we run/reload the app again, the button is no longer visible. Success!

One place left to refactor to move all the "hide" logic: detailsPage.js. We do exactly the same thing, comment out the code hiding the button, run/reload the app and see that button is there, add the code for queueing the event, run/reload the app again and see that the button is no longer there when navigating to detailsPage.html.

Refactoring, moving "show"

At this point, I'm getting more confidence that my mental model matches the reality, which means that I can start to make bigger steps. I add another temporary event handler in default.js,

WinJS.Application.addEventListener("fullViewPossibleChangedTmp", function (e) {
  var appbar = document.getElementById('appbar');
  var appbarCtrl = appbar.winControl;
  appbarCtrl.showCommands(["view"], false); // changed this from hideCommands to showCommands
});

And I comment out the following code in splitPage.js and add the line that queues the event

//var appbar = document.getElementById('appbar');
//var appbarCtrl = appbar.winControl;
//appbarCtrl.showCommands(["view"], false);
WinJS.Application.queueEvent({ type: "fullViewPossibleChangedTmp"})

Then I run/reload the app and sees that button is still being shown in splitPage.html.

Refactoring, joining the event handlers

We want to join the two event handlers to one event handler, which match the design decision we did in the beginning that we would send a boolean as event argument. Being very confident now, we remove the temporary event handler and change the original one to

WinJS.Application.addEventListener("fullViewPossibleChanged", function (e) {
  var appbar = document.getElementById('appbar');
  var appbarCtrl = appbar.winControl;

  if (e.isFullViewPossible)
    appbarCtrl.showCommands(["view"], false);
  else
    appbarCtrl.hideCommands(["view"], false);
});

We then adds the argument "isFullViewPossible" to all three call sites - splitPage.js sends true and the other two sends false. We run/reload the app and see that it works as we expected.

Refactoring, cleaning up

Before we can consider our selves as done, we remove the out commented code. In default.js, we replace WinJS.Application with the variable name "app", which was already is scope. Then we run/reload the app again, no changes.

Summary

There are a couple of thing that we notice here. First, we did an early design decision that the event should have a boolean sent with it, but we didn't need to use the boolean until we joined the two event handlers. In retrospect, I'm not very happy with that strategy - I should have chosen either to use the boolean argument directly in the "hide" refactoring or I should have ignored my "boolean idea" and used two separate events with good names and then joined them in a later refactoring.

I could also have written the two event handlers directly in default.js and using the console to test that they worked, thus creating a "stepping stone" that I could use from the other JavaScript files. Right now, that seems to have been the shortest path to done.

Another thing to notice is that I need to build and deploy the app every time I need feedback of a code change, since I couldn't use Blend for this refactoring, for reasons stated early in this post. Using automatic tests (unit tests) is of course another option for getting feedback, but AFAIK it's still not known how to write and run tests against Metro apps written in HTML5. Hopefully there will be a better unittest story for Metro apps written in HTML5 in the near future.

And there are still things to refactor regarding  the appbar logic, i.e. the event listener on the button itself is set by splitPage.js, which is also breaking the encapsulation. Thus, we should in some way move parts of the logic to default.js.

Resources

GitHub repo with the finished example: https://github.com/gustafnk/FeedReaderTechDays2012
Lots of resources on how to develop Metro apps with HTML5:  http://blog.jayway.com/2012/04/27/windows-8-for-web-developers-techdays-2012-debriefing/
API reference for WinJS.Application: http://msdn.microsoft.com/en-us/library/windows/apps/br229774.aspx
Responsive Design: http://pragprog.com/magazines/2009-09/responsive-design

But there are differences between live tiles in Windows Phone and Windows 8. With a Windows Phone you had greater limitations in display size and performance. In this post we’ll start with a short overview how live tiles work and then continue with an introduction to live tiles in Windows 8.

This post is a part in a series - you can find the full index here.

Live tiles –Windows Phone

With Windows Phone you can create both primary and secondary tiles.

The code for creating these tiles looks (more or less) the same, this example shows how to update the primary tile.

var tile = new StandardTileData
{
     Title = "Sista-minuten",
     BackgroundImage = new Uri("/Assets/tile.png", UriKind.Relative),
     Count = 2,
     BackTitle = "Back Title",
     BackBackgroundImage = new Uri("/Assets/tile_back.png", UriKind.Relative),
     BackContent = "Back Content"
};

You notice that:

1. We send in a picture to the front and back
2. We send in a title to the front and back
3. We send in a text to the back
4. We can set a count to get a number in the top right corner of the front side

But we can't do much else. Well – you can play around and generate images runtime in order to fit more data in. The code to accomplish this is usually messy and hard to change.

Live Tiles – Windows 8

It is a little different for Windows 8. To start with you got two different form factors for tiles – square and rectangular. Which version displayed is totally up to the user.

• Square
  These tiles (regarding form factor) reminds us a lot of the tiles that we are used to from Windows Phone. Just could speculate that you have the same limitations as well – this is not the case. More information coming up!
• Rectangular
  Rectangular tiles are bigger and bigger tiles gives us more space for information. So you can look at a rectangular tile as a panoramic window to your application where you can show even more information. As earlier mentioned, it is the user that controls if the rectangular or square tile should be visible. Square is default, so you must always include a square tile as well.

Besides the different sizes, Microsoft has also addressed the problem with developers having to hack together an image runtime in order to display information. When updating a Windows 8 tile you simply use one of the 44 templates that are available. So take for example the code below.

XmlDocument tileXml = TileUpdateManager.GetTemplateContent(TileTemplateType.TileSquareText02);
XmlNodeList tileTextAttributes = tileXml.GetElementsByTagName("text");

foreach (var tileText in tileTextAttributes)
{
    tileText.InnerText = "Some text";
}

var tileNotification = new TileNotification(tileXml);
TileUpdateManager.CreateTileUpdaterForApplication().Update(tileNotification); 

It will generate a tile with a title and smaller text below. In our case it will say “Some text” in both of them.

Yes – no more hacking together images in order to get a richer tile with more information.

No – the code you have for your Windows Phone tile today cannot be reused and needs to be rewritten.

There’s more

In addition to the new templates there is one more new thing worth mentioning – the notification queue. We can, quite simply, activate a cycling between the five last updates. So all that we do is basically to just keep on updating the live tile and then Windows 8 will take care of cycling the updates.

This means that we don't have to constantly update our tile in order to give an impression that the application is alive. We can just add new updates whenever we feel like it and the hand over the responsibility to Windows to make it look alive. The code to activate this functionality...

TileUpdateManager.CreateTileUpdaterForApplication().EnableNotificationQueue(true);

...is not very complex.

Below, you find the slides and also the links to many of the resources that we used when working on the presentation material. You find the code for the final demo here:

https://github.com/gustafnk/FeedReaderTechDays2012

The links

Resource sites

Microsoft Dev Center - Metro Style Apps
http://msdn.microsoft.com/en-us/windows/apps/br229512.aspx

Build 2011 on Channel 9 (Lots of great videos!)
http://channel9.msdn.com/Events/Build/Build2011

Blog posts

Introduction to developing Metro applications in HTML5

Stephen Walter has many nice intro posts on developing Metro applications with HTML5.
http://stephenwalther.com/blog/archive/category/metro

"What's new in the Beta"

What’s New in the Beta Metro/JS Templates for VS11
http://www.sellsbrothers.com/Posts/Details/12716

Migrating your apps from Developer Preview to Consumer Preview
http://blogs.msdn.com/b/windowsappdev/archive/2012/03/08/migrating-your-apps-from-developer-preview-to-consumer-preview.aspx

What’s changed for app developers since //build/
http://blogs.msdn.com/b/windowsappdev/archive/2012/03/01/what-s-changed-since-build-part-1.aspx
http://blogs.msdn.com/b/windowsappdev/archive/2012/03/06/what-s-changed-for-app-developers-since-build-part-2.aspx

Tutorials

Create your first Metro style app using JavaScript (This is the tutorial that we based our final demo on!)

http://msdn.microsoft.com/en-us/library/windows/apps/br211385.aspx

How to cook a complete Windows 8 application with HTML5, CSS3 and JavaScript in a week
http://blogs.msdn.com/b/eternalcoding/archive/tags/windows+8/

Quickstart: adding a SemanticZoom
http://msdn.microsoft.com/en-us/library/windows/apps/hh465492.aspx

Technology specific posts

HTML, CSS, and JavaScript features and differences
http://msdn.microsoft.com/en-us/library/windows/apps/hh465380.aspx

Hands On: CSS3 Grid Layout (IE10 only)
http://ie.microsoft.com/testdrive/Graphics/hands-on-css3/hands-on_grid.htm

Quickstart: Using single-page navigation
http://msdn.microsoft.com/en-us/library/windows/apps/hh452768.aspx

Security contexts
http://msdn.microsoft.com/en-us/library/windows/apps/hh465373.aspx

Grouping and Semantic Zoom
http://debugmode.net/2012/03/21/listview-binding-with-grouping-and-semantic-zoom-in-windows-8-javascript-metro-application/

WinJS Promises: then and done
http://www.sellsbrothers.com/Posts/Details/12717

Making HTML safer: details for toStaticHTML
http://msdn.microsoft.com/en-us/library/windows/apps/hh465388.aspx

HTML AppBar control sample
http://code.msdn.microsoft.com/windowsapps/App-bar-sample-a57eeae9

Videos

Debugging your Metro style apps using HTML
http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-514T

Introducing the Windows libraries for JavaScript
http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-501T

Building Metro style apps using JavaScript
http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-527C

WinJS Promises #1
http://mtaulty.com/CommunityServer/blogs/mike_taultys_blog/archive/2012/04/11/winjs-promises-1.aspx

Some issues we had

Blend For Visual Studio 11 get an error
http://stackoverflow.com/questions/9760643/blend-for-visual-studio-11-get-an-error

We, naturally, went with resource files when implementing Reseguidens sista-minuten application. We also chose to read from the resource file in our view models and then databind to the view. We did this because it is simpler to add dynamic data with string.Format(…) in the view model.

In this post we’ll explain how we used resource files when implementing the Windows Phone application, and how we changed it for Windows 8.

This post is a part in a series - you can find the full index here.

New file type

First of all, before I say anything else, I would like to point out that the resx file type, that we are used to, has been switched to a resw file type in Windows 8. This means that you cannot directly reuse your old resource files.

This is really no problem. You simply select all in your old resx file and copy it into your new resw file.

Databind texts from the view model

Pro – as we mentioned earlier, is that you easily can format the text when mixing it up with data. Con – you need to write a lot of extra code. Below are some code that we just cut from a view model in the Windows Phone application. Our resource file is named AppResources.

public string DateToTitle { get {
  return AppResources.DetailPivot_DateToTitle; } }
public string TripLengthTitle { get {
  return AppResources.DetailPivot_TripLengthTitle; } }
public string InfoTitle { get {
  return AppResources.DetailPivot_InfoTitle; } }

So, this won’t compile in Windows 8. The handling of resource files has changed. If we want to bind the text resources in a similar manner in Windows 8 we first need to initiate a ResourceLoader.

var resourceLoader = new ResourceLoader("AppResources");

Then to get the values we write.

public string DateToTitle { get {
  return _resources.GetString("DetailPivot_DateToTitle"); } }
public string TripLengthTitle { get {
  return _resources.GetString("DetailPivot_TripLengthTitle"); } }
public string InfoTitle { get {
  return _resources.GetString("DetailPivot_InfoTitle"); }

So gone is the type safe static methods, instead we have strings (o_O). I don’t know why or how this decision was made, but in either case it doesn’t feel right to fetch the texts by string keys in the view model anymore. Not at all.

Bind directly to resource files in the view

This is the second option. This option is of course available in Windows Phone as well. But then you would preferably do it via a proxy and yes, it becomes quite messy for a functionality that really should be very simple.

How does it work in Windows 8 then? Well – better.

In Windows 8 you got a new convention based way to bind resource keys to a view. Let us look at an example.

<TextBlock x:Uid=”SearchPageTitle” />

Note that the only thing specified is the Uid, it will bind to this.

No other code is necessary. The binding is handled by conventions that look at the resource name and the Uid and then match up the ones that fit. Very, very neat.

However you did it on your Windows Phone

You’ll probably end up rewriting some of the code for Windows 8. Luckily, it’s really simple to copy texts from an old resx file to a new resw file. On a personal note – we think that the convention based binding in Windows 8 feels much more modern and slick than the bulky old way.

Code

Slides

Apart from the XNA installation problem, the WP SDK was no problem to install and all seemed fine, until I opened up the Windows 8 project in Blend… or actually tried to open it up.

Whatever I did I was greeted with the same message:

I tried a number of (time consuming) things here, repair of VS11, uninstall of Blend 5 beta and reinstall and in the end a complete reinstall (as in uninstall/install) of Visual Studio 11. No luck.

The I actually started to read the error message:

… The imported project "C:\Program Files (x86)\MSBuild\Microsoft\WindowsXaml\v10.0\Microsoft.Windows.UI.Xaml.CSharp.targets" was not found. Confirm that the path in the <import> declaration is correct, and that the file exists on disk. …

First thought was to check the project file but why would I need to change that, it worked before. Nope, the problem is obviously that the MSBuild targets are not found where it’s supposed to be.  Second try was to copy the actual files to the v10.0 path. That didn’t do it either, led to a couple of new problems instead.

Finally I found the problem after some experimenting (remember, this is Windows 8, searching the net will get you about 3 hits – none of them relevant). The solution was to add an Environment variable to the system to get it running.

1. Right click on Computer, select Properties
2. Select Advanced system settings
3. Down to the right you find Environment variables (they get a bit harder to find for each version of Windows…)
4. Add the System variable VisualStudioVersion with a value of 11.0 and that’s it

Now open up Blend 5 and load your Windows 8 project!

All this has changed in Window 8, navigation feels more modern and easy to use. In this article we’ll take a closer look at the old and new way of navigating.

This post is a part in a series - you can find the full index here.

Differences

There are two big differences in how navigation works on Windows Phone and Windows 8.

1. Forward

• On Windows Phone, pages are navigated to using a Uri and data passed as a query string
• On Windows 8, pages are navigated to by passing the type, and data passed as an object

2. Back

• Windows Phone has a physical back button and a back stack
• Windows 8 has to implement a back button, if one is wanted, within the UI

This means that the navigation code will have to be rewritten and data passed differently.

We feel that the Windows 8 way of navigating is preferable. Especially passing data is much better done by passing objects than sending simple values through the query string.

One could serialize an entire object as XML or JSON and pass on the query string, but that is a sub-optimal solution, and the query string is limited to 2050 characters and hard coded strings are needed to read from the query string.

Navigation

So, lets begin by looking at how navigation between two pages is done on Windows Phone.

// navigate
private void NavigateButton_Click(object sender, RoutedEventArgs e)
{
     NavigationService.Navigate(new Uri("/Page.xaml?key=value", UriKind.Relative));
}

//receive data
protected override void OnNavigatedTo(NavigationEventArgs e)
{
    string value = NavigationContext.QueryString["key"];
    base.OnNavigatedTo(e);
}

Nothing you haven’t seen before, lets dive straight to the Windows 8 way of navigating. Our setup is a main page containing a Frame in which all pages will be shown.

<Grid Background="{StaticResource BackgroundBrush}">
     <Frame x:Name="ContentFrame" />
</Grid>

Then what we’ve done is sent our “ContentFrame” into a static Navigate class.

public static class Navigate
{
     private static Frame _rootFrame;
     public static void SetRootFrame(Frame rootFrame)
     {
          _rootFrame = rootFrame;
     }
     public static void To(Type page, object data)
     {
          _rootFrame.Navigate(page, data);
     }
}

This gives us the ability to, wherever we are in our application, navigate like this:

Navigate.To(typeof(SearchPage), searchQuery);

And receiving data is as simple as:

protected override void OnNavigatedTo(NavigationEventArgs e)
{
     var searchQuery = (SearchQuery)e.Parameter;
}

The big advantage here is getting rid of all magic strings. The risk of misspelling and running into run-time errors is gone now that we use the compiler as our spell checker. Plus, it’s a heck of a lot more convenient to pass data as objects instead of strings.

Page cache

When pressing the back key in a Windows Phone application to go back, two things will happen:

• You’re taken back to the previous page (or out of the application if you were on the start page)
• A saved page is loaded, i.e. a page that still has all the data it had when you navigated away from it

If you implement a back button on Windows 8 and use it, you will soon realize that you are not taken back to a cached instance of the page, instead the page that you navigate back to is created again. Hence if you are on a search page, tap on an item in the search result and then go back the search result will be cleared, very frustrating.

To get around this you could either save your view models in a cache and load those, or…

public SearchPage()
{
     InitializeComponent();
     NavigationCacheMode = NavigationCacheMode.Enabled;
}

That row will activate the cache and give the same behavior as Windows Phone has, very nice.

Lemma: Suppose that from some configuration C, the schedules µ1 and µ2 lead to configurations C1, C2, respectively. If the set of processes taking steps in µ1 and µ2, respectively, are disjoint, then µ2 can be applied to C1 and µ1 can be applied to C2, and both lead to the same configuration C3.
Proof: The result follows at once from the system definition, since µ1 and µ2 does not interact.

I realized this could be rewritten with CQRS vocab:

Call all events resulting from applying a command onto an entity, a schedule.
Suppose that from some initial state of an aggregate C, the schedules µ1 and µ2 lead to states C1, C2, respectively. If the commands resulting in schedules µ1 and µ2, respectively, are disjoint, then µ2 can be applied to an aggregate in state C1 and µ1 can be applied to an aggregate in state C2, and both lead to the same final aggregate state, C3.

This gives us the vocabulary for reasoning about when commands cause the same end state, no matter their ordering - they are then disjoint! We can start writing code like this (pseudo):

InternalStateOfAllFields

could simply hash all fields and compare the hash.

There would also need to be a method for specifying what commands require previously sent commands to be applied, filtering out those 2-variations of commands which don't share common initial states from previously applied schedules.

Would this hold? Comments?

new Variations()

Windows Phone projects always break at unhandled exceptions. You can select Exceptions from the Debug menu and then change these settings, but changes are not honored. This command is present only in the Windows Phone Add-in for Visual Studio 2010.

(MSDN, scroll down to “Exception handling configuration”. Emphasis is mine.)

Keynotes

As it happened two of four keynotes on this Scala conference were mostly about other programming languages than Scala. The opening talk that Guy Steele did was about Fortress. Steele is a computer scientist who worked on the early Java versions as well as other languages. Fortress is a programming language designed for high-performance computing trying to push the boundaries on providing a highly readable syntax, especially for a mathematical purpose. In his talk Steele showed similarities and difference between Scala and Fortress. His talk gave some very interesting insights into language design and showed how both languages can learn from each other. He mentioned that programming should be like writing on a whiteboard...

Simon Peyton-Jones in bare foot action

The second keynote was held by Simon Peyton-Jones who is a researcher at Microsoft Lab in Cambridge. His area of research is mainly Functional Programming and Haskell. He demonstrated a lot of Haskell codes and walked through a practical actor implementation in Haskell.

The creator of Scala and founder of Typesafe - Martin Odersky - held the third keynote on the second day of conference on "Where Scala is going?". He quickly discussed the new features and improvements in future 2.10 release. The greatest news is that you can use Scala reflection API in 2.10. Martin mentioned the difficulty of integrating the reflection API into the Scala core and how they have managed to do that. Then he talked about Scala Macro! It will be experimental in 2.10 release but it's a start of a game changer in Scala ecosystem.

Martin Odersky on Where Scala's going?

The last keynote was given by Antony Rose the founder Zeebox. The talk was mainly about visionary behind a revolutionary social TV and not really something about Scala at all. The only thing he mentioned was that they use Scala in their backend system.

There were around 70 great talks totally at the conference. Here are some of our personal favourites:

Talks

Akka2: Distributed by Design: Jonas Bonér talked about the new cluster module in Akka.

The Future I was promised: Viktor Klang talked about Futures and Promises and how they can be used to compose asynchronous dataflows.

Concurrent Programming with Futures, Offers and Brokers: Marius Eriksen from twitter explained how they tackle concurrency issues with Futures, Offers and Brokers.

Stackless Scala with Free Monads: Rúnar Bjarnason showed how Trampolining technique can be used to get rid of stack overflow problem.

How to map and fold over an HList in shapeless: Miles Sabin talked about Shapeless and how one can do map and fold on an heterogeneous list

Practical Scalaz: Using One of Scala's Most Controversial Libraries: Jordan West discussed how Scalaz library is heavily used at StackMob

Spark in Action: Matei Zaharia demonstrated Spark that is a cluster computing framework that outperforms Hadoop by up to 30x in applications where repeated map reduce tasks have to be performed.

Spray: REST on Akka: Mathias Doenitz talked about Spray that is a suit of lightweight Scala libraries for building and consuming RESTful web services on top of Akka

High Performance Embedded DSLs with Delite: Arvind Sujeeth explained how one can use Delite that is a framework for building high performance embedded DSLs in Scala.

Pettswood - Executable Documentation for Scala Acceptance Testing: Chris Agmen-Smith gave a lot of insight on having users describe the requirements directly in his Pettswood tool.

Making games and solving puzzles in Scala: 12 year old Shadaj Laddad gave a great talk and explained how he learned programming in Scala and how he has fun with it solving puzzles and writing games.

Conclusions

• A very high level on the conference talks. It appears that there has been a lot of advances recently in Scala.
• IntelliJ IDE and Scala IDE are both powerful enough to enable handy and cool features for Scala enthusiasts. The Scala tool support is getting better all the time.
• Scala community has shown a great passion for improvement and being open to critics that we think is really valuable. See Scala Improvement Process (SIP) for an example.
• Some languages exist in Industry and some other exist only in academia. Scala is where academy and industry meet each other. There were around 14-15 people from EPFL in the conference and that are mostly PhDs. It's a secure feeling that a lot of researcher and PhD students heavily contribute to Scala community while keeping the stability for industry.
• Skillsmatter did a really good job organizing Scala Days, and many of the talks already came up as podcast during the conference. You'll find them here: http://skillsmatter.com/event/scala/scala-days-2012

In Reseguiden’s application we are not actually saving any data in our cache. This is because all data really need to be fresh so we really can’t cache it any longer than the application runs. But we do save previous searches (only the query, not the result) that makes it possibly for users to flip through previous searches in a pivot even in the application is restarted.

The plan is to implement the same functionality for the Windows 8 client.

This post is a part in a series - you can find the full index here.

The Windows Phone code

Today, when persisting to Windows Phone isolated storage we use the following code.

protected void Save(string directory, string fileName, string data)
{
    using (var store = IsolatedStorageFile.GetUserStoreForApplication())
    {
        using (var writer = new StreamWriter(store.OpenFile(GetPath(directory, fileName), FileMode.Create)))
        {
            writer.Write(data);
        }
    }
}

No magic, just simple code, but one thing to note – all is written synchronously. So if we don’t put this on a separate thread, than the UI thread, we risk freezing the UI while reading/writing data.

Different types of storage

Before we throw ourselves at the Windows 8 implementation, it is probably best to look a little bit closer at the different storage options that we have.

• Local
  Works basically the same way as the storage that we are used to when developing for Windows Phone. Persists data locally on your device and the only way for a user to remove the data is to uninstall the application. You would typically put data here that you don’t need to share between devices and data that your application depends on to work.
• RoamingData that syncs between devices (using the users live id). Here you typically place data containing settings and preferences. This storage should not be used to store large amount of data.
• TemporarySimilar to local, the difference is that there are no guarantee that this data is there when your application asks for it. The user can clean it at any time using a disc cleanup. This basically means that the application never really can count on the data being there. Perfect to use as a cache.

So, in order to save our earlier searches we will use temporary storage. Thus allowing the user to clear old searches without us having to implement that functionality in our application.

Implementation for Windows 8

First of all, the one thing in common for all the storage types is that you access them all through Windows Runtime, compared with Windows Phone where we access storage through .NET. This means that our code will look quite different in comparison.

Since this is Windows 8 we got access to await and async which is good since any method call that potentially could take longer than 50ms is asynchronous in Windows Runtime.

public async Task SaveFile(string fileName, string content)
{
    var temporaryFolder = ApplicationData.Current.TemporaryFolder;
    var file = await temporaryFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);          

    IRandomAccessStream writeStream = await file.OpenAsync(FileAccessMode.ReadWrite);
    IOutputStream outputStream = writeStream.GetOutputStreamAt(0);

    var dataWriter = new DataWriter(outputStream);
    dataWriter.WriteString(content);

    await dataWriter.StoreAsync();
    await outputStream.FlushAsync();
} 

Two thing worth mentioning here. First of all – we don’t need to use using since nothing needs to be disposed. Secondly – we do this completely asynchronously. So if we would have stored/read 5Mb JSON, this code would have been much better than the Windows Phone code.

Since we are using the temporary folder we also get the clear-cache-feature for free. They user doesn’t need to uninstall the application in order to clear whatever we are saving. We could, of course, have added functionality for clearing the cache in our application – but why bother if Windows 8 can do it for us?

Introducing the Jasmine Maven Plugin

At first glance the Jasmine Maven plugin seem to be perfect for the job. It supports running our tests headlessly from Maven using HtmlUnit as well as from a Jetty container. It's simple to get started and you're up and running in no time:

 
mvn jasmine:bdd
 

This goal starts an embedded Jetty server that assumes that the production code is in the src/main/javascript folder and the Jasmine specs are in the src/test/javascript folder. Connect to http://localhost:8234 and all your Jasmine specs are executed and the outcome is presented on an HTML page. This gives you a rapid turn-around time, you can simply change the Javascript code and hit refresh in the browser and the specification suite is re-executed. Nice! In my current project this almost worked out of the box. All we had to do was to change the jsSrcDir property in our Jasmine Maven plugin configuration in the pom.xml to ${project.basedir}/src/main/webapp/javascript and we were able to run our specifications.

How about headless?

I was very impressed by how simple it was to get everything working using the jasmine:bdd goal. But when running the jasmine:test to exectue the specs in headless mode things did not work as smoothly:

 
[ERROR] Failed to execute goal com.github.searls:jasmine-maven-plugin:1.1.0:test (default) on project my-project: The jasmine-maven-plugin encountered an exception:
[ERROR] java.lang.RuntimeException: org.openqa.selenium.WebDriverException: com.gargoylesoftware.htmlunit.ScriptException: ReferenceError: "service" is not defined. (file:/home/johan/devtools/java/projects/my-project/code/target/jasmine/src/some.js#3)
..
 

The reason is that a function called "service" couldn't be found in some.js which is the Javascript file we're testing. It's actually not that surprising when you think about it. When using the jasmine:bdd goal Jetty loads the index page of our web application automatically and thus all scripts are loaded. When running outside the container, HtmlUnit doesn't know that some functions in some.js depends on functions defined in other Javascript files. We need to tell Jasmine to load them before it executes these specifications. This is done by adding preloadSources to the Jasmine Maven plugin configuration. Let's say that the "service" function is defined in x.js which in turn depends on y.js then this is how you would configure it:

 
<configuration>
  ..
<preloadSources>
 	<include>${jasmine.test.resources.folder}/y.js</include>
	<include>${jasmine.test.resources.folder}/x.js</include>
	<include>${jasmine.test.resources.folder}/some.js</include>
  </preloadSources>
  ..
</configuration>

After this change we were able to run the specs both headlessly using jasmine:test and inside the browser using the jasmine:bdd goal. Keep in mind that the order of includes in preloadSources are important. Also if you have cyclic dependencies between your Javascript files you will need to refactor them.

Using JQuery Fixtures

When testing a function that interacts with the DOM it's good to be able to provide some fixture data that can be loaded during the test. One way to do this is to use the Jasmine JQuery plugin. It allows you do load HTML fixtures from your test, for example:

myfixture.html

 
<div id="fixtureId">some content</div>
 

Usage:

 
loadFixtures('myfixture.html');
 
// Run test
some.methodToTest();
 
// Expect that the methodToTest has modified the content in the div
expect($('#fixtureId')).to...;
 

In Jasmie JQuery you can configure the path to where it should look for the fixtures, e.g.

 
jasmine.getFixtures().fixturesPath = 'spec/fixtures';
 

This will intruct the plugin to look for fixtures in the target/spec/fixtures folder on the file system. But now we run into a problem. The reason is that the jasmine:bdd and jasmine:test goals look for resources in a different ways. When using jasmine:bdd the path to the folder where the fixtures are located cannot be configured to a folder on the file system. Rather it has to be a resource on Jetty server that serves out the static HTML fixture files. The jasmine:test on the other hand require the fixtures to be in the target folder of your Maven build. This has actually been reported as a bug on the Jasmine Maven plugin web site.

The work-around

So how can we fix this? Unfortunatly there's no 100% clean solution unless you want to fork the Jasmine Maven project but as a work-around we can make use of Maven profiles. The trick is to set a different fixture path when running the jasmine:test and jasmine:bdd goal. This can be achieved by pre-loading a different script for configuring the fixture directory for each goal. Assume that we have our HTML fixtures in the src/test/javascript/fixtures folder on the file system then these are the two different scripts needed:

file_system_fixtures.js

 
jasmine.getFixtures().fixturesPath = 'spec/fixtures';
 

web_resource_fixtures.js

 
jasmine.getFixtures().fixturesPath= 'src/test/javascript/fixtures';
 

In our project we run mvn clean install (and thus run the jasmine:test implicitly during test execution phase) much more often than jasmine:bdd and for this reason it's probably better to configure the latter in a special profile. The first thing to do is to create a Maven build property that points to the file_system_fixtures.js file:

 
<properties>
      <jasmine.test.resources.folder>${project.basedir}/src/test/resources/jasmine</jasmine.test.resources.folder>
      <jasmine.fixture.setup>${jasmine.test.resources.folder}/jasmine_fixture_setup_test.js</jasmine.fixture.setup>
</properties>
 

Secondly we alter the preloadSources configuration under Jasmine Maven plugin to load the Jasmine JQuery script and configure the correct fixture folder by running our file_system_fixtures.js script configured by the build property:

 
<configuration>
  ..
<preloadSources>
        <include>${jasmine.test.resources.folder}/jasmine-jquery-1.3.1.js</include>
        <include>${jasmine.fixture.setup}</include>
 	<include>${jasmine.test.resources.folder}/y.js</include>
	<include>${jasmine.test.resources.folder}/x.js</include>
	<include>${jasmine.test.resources.folder}/some.js</include>
  </preloadSources>
  ..
</configuration>
 

Now when running jasmine:test the fixtures will be found on the file system but we still need to make things work for the jasmine:bdd goal. To solve this we create the following Maven profile:

 
<profiles>
<profile>
    <id>bdd</id>
<properties>
        <jasmine.fixture.setup>${jasmine.test.resources.folder}/web_resource_fixtures.js</jasmine.fixture.setup>
    </properties>
  </profile>
</profiles>
 

What we do here is to override the jasmine.fixture.setup property to point to our web_resource_fixtures.js script which configures the Jasmine JQuery fixture folder to work in Jetty. Thus whenever you need to use jasmine:bdd you also need to use the bdd profile:

 
mvn jasmine:bdd -Pbdd
 

Conclusion

If you've read this far you've probably seen that it's not trivial to get Jasmine tests running in Maven, at least not if you want it to work in both headless mode and non-headless mode at the same time. To me this is a big obsticle when trying to convince people to start writing unit tests for Javascript code. These things simply have to work, we need the feedback from our continous integration server and it needs to be simple and fast to use during development. The work-around suggested here is not perfect but at least it's acceptable once you've configured everything. Hopefully the issue will be resolved in Jasmine Maven in the future and I also hope that this blog can lower the barrier to get started with the testing Javascript from Maven somewhat. I know that this is something that's lacking in many projects.

At first glance, the Guava Cache doesn't look very different from the caches that you probably have written so many times in the past - a fancy Cache class on top of a HashMap with some timeout functionality. Except from now on, you don't have to reinvent the wheel. Digging a little deeper, the Guava Cache also offers different expiration behaviors, along with other features that might come in handy.

The Guava Cache is an incremental cache, in the sense that when you request an object from the cache, it checks to see if it already has the corresponding value for the supplied key. If it does, it simply returns it (assuming it hasn’t expired). If it doesn't already have the value, it uses a CacheLoader to fetch the value and then it stores the value in the cache and returns it. This way, the cache is growing as new values are requested.

The only thing you need to provide is the implementation for the abstract load method of the CacheLoader class. This is the method that is used to fetch the value to be cached. You can do this as an anonymous class, but creating a new class that extends CacheLoader is the way I prefer to do it (it's cleaner and helps when unit testing/mocking). Please note that this method is expected to never return null, or there is no way for the Cache to tell whether this record has not been fetched yet or if it’s value is just empty.

So let's not waste another minute - let's get our hands dirty with the Guava Cache! You will need the Guava jar file, which can be downloaded from the Guava website. Or, if you're using maven, just include this dependency in your pom:

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>11.0.2</version>
</dependency>

The next thing you need to do is to create the Cache object. Caches are created using the CacheBuilder. Let’s look at a basic example of a cache with keys of type String holding Object values:

LoadingCache<String, Object> cache = CacheBuilder.newBuilder()
  .build(new CacheLoader<String, Object>() {
     @Override public Object load(String key) throws Exception {
       return new Object();
     }
  });

If we request an Object that is not yet stored in the cache, a new object is simply created by our CacheLoader object. In real life, however, you would probably be digging the value out from something like a database or perhaps a web service.

Using the CacheBuilder, you can specify the characteristics of the cache, like timeouts, max size and other properties. The build() method then takes your CacheLoader as the only argument.

In the next example we will create a cache that holds Animal objects, with a timeout of 5 minutes. This is our very basic non-fancy Animal class:

package com.jayway.guava;

public class Animal {
	private final String name;

	public Animal(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Animal/" + name;
	}
}

Let’s create a cache for our Animals:

LoadingCache<String, Animal> animalCache = CacheBuilder.newBuilder()
  .maximumSize(1000)
  .expireAfterWrite(5, TimeUnit.MINUTES) })
  .build(new AnimalCacheLoader());

The maximum size of the cache is set to 1000 objects. When that limit is reached, the cache will begin to evict the objects that are not recently used (actually, the Guava Cache may start dropping objects before the maximum is reached, see Kevin's comment explaining this).

expireAfterWrite lets us decide how long a cached Animal may live, before it is considered too old and thrown away. We could also set another timeout value using the expireAfterAccess method, which tells the cache to throw away values that has not been read (or written) in a certain amount of time.

The AnimalCacheLoader class is the class responsible for populating the cache, and extends the abstract Guava class CacheLoader:

package com.jayway.guava;

import com.google.common.cache.CacheLoader;

public class AnimalCacheLoader extends CacheLoader<String, Animal> {
	@Override
	public Animal load(String key) throws Exception {
		return new Animal(key);
	}
}

This is enough to make the cache work. To get an Animal from the cache, simply use the get method:

Animal animal = animalCache.get(“monkey”);
System.out.println(animal);

This piece of code will print:

Animal/monkey

and it will place our new monkey in the cache.

As you can see, the Guava Cache is really simple to use, and it can save us time not having to write our own logic for the caching. And if you trust the Google Guava team enough, you don’t have to write unit tests for your cache either (but it could possibly be a good idea to write tests for your CacheLoader.load implementation).

The Guava Cache also has some nice statistics build in, which can be very handy if you want to know how and if your cache is really used. Just call the stats method on the cache and it will give you a nice CacheStats object which has all the numbers you’ll need.

That’s my breif introduction to the basics of the Google Guava Cache. I hope you will find it useful. Read more about Guava at the Guava Project Homepage.

If we had been lucky we would have been able to re use the same libraries in Windows 8. If we had been smart we would have isolated all third party libraries so we easily could swap them.

Since we where unlucky and did not isolate third party libraries properly, we are now writing a blog post about the importance of isolating external components and how to use the built in JSON parser in .NET 4.5.

This post is a part in a series - you can find the full index here.

The problem

To be perfectly clear – the problem is not third party components by themselves. The problem is that we end up with dependencies to libraries that is not built as a Windows 8 library. This is a problem because even if we can reference them in our project, we won’t get it accepted in Windows Marketplace.

In other words – it is futile to cling on to components not built for Windows 8 if you ever want to distribute your application.

JSON parsing

Since we cannot use the JSON parsing provided by ServiceStack.Text (since it is not built for Windows 8 ) we need to replace it with something else. Here we got three alternatives.

1. Ignore everything we said and keep on using it as a proof of concept. We won't get any compilation error but we cannot distribute our application.
2. ServiceStack.Text is open source. Fork, modify and push.
3. Find a replacement. This is what we did – meet JsonObject.

JsonObject has been available as a NuGet package before but has now, much like HttpClient, merged with .NET 4.5. The big advantage of using JsonObject is that it’s similar to ServiceStack.Text in how you use it.

// working with ServiceStack.Text
var departures = json.ArrayObjects("departures").ConvertAll(x => new DepartureIVM(x));

// working with JsonObject
var departures = jsonObject.GetNamedArray("departures");
for (uint i = 0; i < departures.Count; i++)
{
     var departure = departures.GetObjectAt(i);
     Departures.Add(new DepartureIVM(departure));
}

JsonObject is perhaps somewhat chattier, but you could easily get the same syntax with som extension methods.

So, what did this mean for us? Well, basically to go through the entire application and replace all JSON parsing (spread through the entire application) with a Windows 8 compatible version. Not a lot of work, but a lot of time could have been saved if we would have isolated the actual JSON parsing and usage of ServiceStack.Text.

Thoughts about third party components

There are many, many libraries out there that you can use to enhance the user experience or the development experience when creating a Windows Phone application. You got MVVM frameworks, serialization frameworks, Silverlight toolkit, cache frameworks and many more. They all add something (also complexity and another layer of abstraction), but they can also get in the way when porting your Windows Phone application to Windows 8.

If we, for example, had choose to use a MVVM framework, and then not been able to find a Windows 8 compatible version, we would have been stuck with a lot of unusable code that we would have to rewrite completely before migrating.

We are all in agreement that you really should try to limit the amount of frameworks you add to a Windows Phone project. Usually, you can manage just as well without them. Often it is even better to write a couple of lines by yourself to get the exact functionality that you need instead of adding a framework that kind of give you that functionality. The risk that you eventually might need to work around your almost-perfect-framework (or get in trouble when converting to Windows 8…) is too big to never reinvent the wheel.

We’ll take a look a the heart of the application – where the data is fetched from the server. Usually, I prefer to do a web request using HttpWebRequest instead of WebClient. Mostly because a callback from a HttpWebRequest is not executed on the UI thread (explained here by Andreas). This gives us the opportunity to do some heavy lifting on a background thread (such as parsing JSON or XML) not ruining the user experience.

But now – the much loved HttpWebRequest, must step aside for HttpClient that came with .NET 4.5.

This post is a part in a series - you can find the full index here.

Using HttpWebRequest

This code is more or less directly copied from our Windows Phone application. As you can see we do a simple web request.

public void DownloadData(string url, Action<JsonObject> handleResponse, Action<Exception> handleException)
{
    var httpWebRequest = WebRequest.CreateHttp(url);
    var requestContext = new RequestContext(handleResponse, handleException, httpWebRequest);
    httpWebRequest.BeginGetResponse(RequestCompleted, requestContext);
}

private void RequestCompleted(IAsyncResult result)
{
    var requestContext = (RequestContext)result.AsyncState;
    try
    {
        var httpWebRequest = requestContext.Request;
        using (var webResponse = httpWebRequest.EndGetResponse(result))
        {
            using (var reader = new StreamReader(webResponse.GetResponseStream()))
            {
                var jsonObject = JsonObject.Parse(reader.ReadToEnd());
                Dispatch.ToUiThread(() => requestContext.HandleResponse(jsonObject));
            }
        }
    }
    catch (Exception e)
    {
        Dispatch.ToUiThread(() => requestContext.HandleException(e));
    }
}

We also send in two actions with the request, that handles either a successful response or a failure. This pattern has worked well for us, but as you can see the code is quite messy. Much of that comes from having to handle the callback (and it gets even worse if we want to do a POST) in a different method.

Using HttpClient

One big reason that HttpClient is so nice to use has actually more to do with language features than HttpClient itself. Let’s take a look on how we can rewrite or web request using HttpClient, async and await.

public async Task<JsonObject> GetAsync(string uri)
{
    var httpClient = new HttpClient();
    var response = await httpClient.GetAsync(uri);

    response.EnsureSuccessStatusCode();

    string content = await response.Content.ReadAsStringAsync();
    return await Task.Run(() => JsonObject.Parse(content));
}

Much nicer isn’t it? We can still do everything that we could do before, the difference is that we can get rid of the callback thus making the code more readable. In fact, we can make it even slimmer!

public async Task<JsonObject> GetAsync(string uri)
{
    var httpClient = new HttpClient();
    var content = await httpClient.GetStringAsync(uri);
    return await Task.Run(() => JsonObject.Parse(content));
}

Very nice indeed. So we have actually replace two methods and 20 lines of code with a single method with 3 lines of code. It’s stuff like this that makes it hard to keep a common codebase between Windows Phone 7 and Windows 8. There are just too many goodies in Windows 8 that you want to use.

Thoughts

We think that  it’s ok to just go wild and do any changes to you want in your Windows 8 project. You can just ignore that it looks different from your Windows Phone project. Later, when Windows Phone 8 arrives you already have a solid foundation that you can re-use when updating your Windows Phone application.

So don’t be afraid of refactoring and improving your existing code. You’ll be able to use it later on.

I wanted

•      a solution that would fit into all of our different projects in my organization
•      something that when applied works in a proactive way with quality
•      an easy to use tool for development teams to work with customers about quality

Working with already existing work

I already knew about James Bachs Heuristic Test Strategy Model, and thought I would use that as a starting point. Or actually, my starting point was the Software Quality Characteristics created by TheTestEye which are originally inspired by James' model. When I later came back to HTSM I realized thats what I was working with as well. Let me explain.

I want to align expectations on quality before development, thus before any quality can be perceived. What I actually want to do within HTSM is to optimize Quality Criteria work for successful delivery. Project environment will briefly be the same in our different projects, thus these parts will not be a part of this exercise. Product elements are usually discussed about just before being developed, and later on I will show how these will be affected by our game. The derived test techniques is something that the team will be able to make decisions on when knowing about the inputs, where Quality Criteria is an important part.

Playing games with Software quality criteria

Quality is a complex thing. To ease the conversation we will talk about the quality criteria, as referred to by James as:
A quality criterion is some requirement that defines what the product should be. By considering different criteria, you will be better able to plan tests that discover important problems fast.

Thus, I take the Software Quality Characteristics and work on them as they would have been requirements. In agile and in my organization we call them user stories or just stories. I print them separately on bigger index cards with the main title and context question a little bigger than the sub-characteristics. Find the index cards here.

Then I play the 20/20 vision innovation game (by Luke Hohmann) with the customer, regarding the quality of the product. I explain to them that we all of course value quality highly, but as with anything there needs to be some sort of prioritization. This will enable the team even more , since they will know what type of quality matters when delivering their stories. The result will be a prioritized list which explicitly states which types of quality matter the most to the business stakeholders.

Value gained

Now I have a common ground to build on when I want to work with quality in our projects. The abstract word of quality has been over bridged with the acknowledged set of quality characteristics that explain themselves with the understandable questions attached.

The tool works in our projects in a proactive way, since it is possible to apply regardless of the project/product context before any development work is done. However it needs to be applied after some common understanding of scope has been reached.

Nothing extra is needed to use this tool, except for the things that is anyway required in our projects like an open minded and active customer and development team.

Real value

The real value in this is not really the prioritized list of quality characteristics. Its the gained discussion on what is important for the customer, that matters. For example, imagine this exercise done when having a project scope of derived user stories but before much effort has been done in development. When speaking about security as quality, it really sounds differently in a customers mind than when talking about the "Use https" story. Then at least there was such a story, but maybe not prioritized high enough. If there is no such story, then maybe it needs to be added before doing anything else. What we are doing is actually taking the discussion about scope from a completely different angle than people are used to, which will give interesting results.

Different viewpoints

Of course I already have some ways in mind to alter this approach.

Prioritization strategy

The 20/20 vision suits well when there is not very many people working on the same set. A colleague of mine pointed this out as a weakness of the tool. If there are more people that should be involved then maybe a partitioning or dotting game would be more suitable. However, since we want to play this game with the people that matter it really has to be a small group of people. If not only THE one person that matters. But of course, if there is a better way to get the prioritization done with the gained discussion being constructive.

Product contexts

There could be certain areas in the product that you are developing that are very different in context, for example if there is an enterprise back-end integration and then having mobile clients. Then you would want to differentiate these by creating separate lists for these, one for the back-end and one for the iOS and Android apps respectively. Why would you separate the two client apps? Logic behind business decisions like this is not trivial, but an example would be that the business strategy suggests the iOS app needs to be launched first with an astounding success while the Android app needs to fill the needs for the early adopters that dont have iOS devices. This app maybe does not need the same type of stability focus as the iOS app, but with more options for compatibility in the fragmented Android domain.

Story or feature level quality characteristics

Some stories or features are more important or bigger (or whatever more) than others. If this is the case and there are uncertainties regarding the quality expected at delivery it might be useful to take out the quality characteristics index cards to facilitate a customer discussion around the quality. It does not have to take very long for either side to realize where the solution needs to be cut.

Breaking quality stories into pieces

People will have a hard time prioritizing, that is to be expected. Some parts of a certain quality may be more important than the rest of it and some other quality. I think it should be preceded with awareness, but you might in some cases want to break away a sub-quality from its index card to enable the discussion to go forward to completeness instead of a stale.

Internal and external quality characteristics

Depending on the context it could be important to blend internal and external quality. However, I think it might be important to have them separated in the discussions. I suspect that in our projects we will probably most of the time need to have them separate.

Discussion

It should be noted that I have not tried the approach on many projects just yet. My colleagues that I shared the idea with have first been suspicious to it, but then mostly come to the conclusion that it might be an easy way of getting to the right discussion with our clients regarding quality.
I tried it with two different stakeholders in my current project, although not /the one that matters most/. They both had their views on the quality needed, but the prioritization game actually got them to talk to me about quality in a more understandable way. Or actually, by getting them to express their needs in their own words, I could translate the general wordings of quality characteristics to the project context. That way we got on the same page of expectations on quality.

The problem is quite easy to fix. In this post we will discuss why XAML has moved and how you deal with it.

This post is a part in a series - you can find the full index here.

Why move it?

In order to understand why they have made the trouble to move XAML I think that we first need to look at all languages and technologies that can be used building Windows 8 metro applications.

• HTML 5 and Javascript
• XAML and C++
• XAML and VB.NET/C#

So – you can use any of these to build metro applications and they all got in common that they use Windows Runtime to access native functionality in Windows 8. Since all got Windows Runtime in common it could be a good idea to place common functionality there as well, for example how to define the UI. So by moving XAML (and HTML 5) into Windows Runtime it is possible for both C++ and VB.NET/C# to use the same XAML library. Something that was not possible as long as XAML was a part of .NET and was compiled to IL code.

So what does this mean for us? Very little it turns out. Basically all XAML that we are used to in .NET are available in Windows Runtime. All that we really need to do is to switch namespace.

Solution

As I mentioned earlier – there is no big deal to correct the compilation errors that occurs when moving all of our code to Windows 8. Here is a list showing the namespaces in .NET and Windows Runtime.

As you can see it is quite obvious what needs to be done (feel free to optimize by using Ctrl + Shift + F,H).

That is all.

This is, of course, one of the simpler fixes that you need to do (and that you cannot escape) while converting to Windows 8. Look at it as a warm up for the issues further ahead.