1. Azure Service Bus
2. Hadoop on Azure
3. Node.js and Java on Windows Azure
4. Azure Websites
5. Azure Virtual Machines

I was in charge of the third session. I started talking about the different technologies supported by Azure and then I focused on just 2 of them: Node.js and Java. In both cases I did a brief explanation and then I run a demo.

For Node.js I deployed to azure the Pictionary sample developed by my colleague David Frassoni (alias Harry). I did it from a machine running Ubuntu and using the new Git Publishing feature offered by Azure.

In the case of Java, I create a Java Web application using Tomcat 7, Eclipse for JEE Developers and the Eclipse Plug-in for Windows Azure. I run the application i the local emulator and then showed how to deploy it to Azure.

Here is the slide deck I used in the session.

Other alternative, that I think is more frequently used, is to have only one build server for the whole organization and several build agents. When using this strategy the build server concentrate the all build configurations, checkouts the code and delegate to an agent the execution of the build steps. If you have two projects with incompatible software requirements (i.e. one project running on Windows and other on Linux), then you could setup one Windows agent and Linux agent.

Last week I setup an environment following this second alternative. I took 2 machines, in the first one I installed a full TeamCity environment: server and agent, and in the second one I installed just an agent. It was very straight forward. One additional benefit of this setup is that it allows run builds in parallel.

Backlog basics (or preliminary definitions)

Some people tend to think that a backlog is just a simple list of items. I don’t think that is true; I try to use the word backlog to refer to a list of items that are prioritized and estimated. Of course, the prioritization is done by the customer while the estimation is done by the technical team.

What are the items in the backlog? Depending on the context, the items can by user stories, use cases or simply tasks. When working on a development project I try to avoid having tasks in my backlog because in many cases tasks do not add value to the customer who prefers user stories. In most cases, what really adds value to the customer is working software and that is represented by a group of user stories.

The backlog is commonly used to organize work but is also used to provide visibility of the project’s status .

Backlog recommendations

Make the status EXPLICIT

A very common strategy to show the status in a consumable way is to use a semaphore pattern (green-yellow-red): Done, In progress, Blocked, Pending. Using this convention is very easy to detect smells. For example, if there are many yellow stories it could mean that there is too much work in progress, and you are not focused on completing specific stories.

Note: if you are using a dashboard, then the status is given by the position of the item in the dashboard.

Limit the work in progress

Completed items are the only real measure of progress, so you should focus on completing items instead of accumulating stories in progress. This leads us to the following question: How many stories can be in progress at the same time? There is no single answer; it depends on the length of time, but each person should work on ONE item at a time. In a particular situation it could be that two items are closely related, so you could decide to work on them both at the same time. But if you have 3 team members and 10 items in progress, you should look at the situation.

INVEST in SMART

When working with user stories, it is good practice to keep the INVEST acronym in mind:

• Independent
• Negotiable
• Valuable
• Estimable
• Small
• Testable Testable

Beyond user stories, I think these considerations are very useful when creating a backlog, no matter what your items are.

Other famous acronym related to planning and very used when defining goals is SMART:

• Specific
• Measurable
• Achievable
• Relevant
• Time-boxed

More information about these acronyms can be found here.

My backlog

The following picture is a screenshot of the backlog of my current project. I have highlighted some important properties:

I am working on a small application that I know it will grow, so the traditional Sinatra application could be a mess when I have more than 10 routes.

So the strategy I have chosen is to create a base class called BaseController inheriting from Sinatra::Application, this base clase will handle global application settings.

#./base_controller.rb
require 'sinatra/base'

class BaseController < Sinatra::Base
  get '/' do
    'Home (base controller)'
  end
end

Then, I create one controller class for each application module, each of this controllers should inherit from my BaseController.

#/controllers/module1_controller.rb
require File.join(File.dirname(__FILE__),'..', 'base_controller.rb')

class Module1Controller < BaseController
  get '/' do
    'Module 1'
  end
end

Finally, in the config.ru file I define the base routes for each controller.

# config.ru
require './base_controller.rb'
require './controllers/module1_controller.rb'

map '/' do
  run BaseController
end

map '/module1' do
  run Module1Controller
end

Note: the code snippets above assume that the base_controller.rb and config.ru files are located in the root directory while every all controller files are located under “/controllers” directory.

You can download the source code from here.

Let’s start by installing jekyll:

$> sudo gem install jekyll

Very easy and straightforward.

Now create a directory for your site and create the following files/folders in it (this structure is basically what Jekyll’s documentation suggests):

• _config.yml, this file stores the configuration data that is used by Jekyll. Most of this information can assume default values or the values can be specified as command line arguments when invoking Jekyll. I suggest specifying the destination argument, which specifies where output files will be placed.
• index.html, this will be the landing page of your site, but in order  for this file to be processed by jekyll we need to add the following line at the top of the file. This will indicate to jekyll which layout to use in order to render the page as well as its title.

---
layout: default
title: jekyll-spike
---

• _layout, as you may imagine this folder will contain the files that define the layout of your pages (in .net we would say the “master pages”)
• _post, this folder is where you will place the markdown files with your posts

That is pretty much all; now you can add the classic folders for static resources like images, css, etc.

Now to generate your website, just open a terminal in the root directory of your application and call jekyll

$> jekyll

This will create a whole static site under the folder you specified as the destination in the _config.yml file. Now, every time you want to add a new post/page, just create a markdown file under the _posts folder and then execute jekyll to regenerate the site.ust ese

There is also an option in jekyll to generate the site and start a webserver to host the site all at once, just execute

$> jekyll --server

Well this is all for now. If you want, you can download a zip file with this basic structure from here.

Out of the sessions I attended, I would have to say that the most interesting were those given by Marcus, Mariano Peck, Hernan Wilkinson and Dale Henrichs.

We held two sessions, Angel gave one on Smalltalk, C# and Javascript and I gave the other on Pharo Customization.

So, here are the steps I perform to get my Ruby development environment up and running on Windows 7.

I started by downloading Ruby from http://rubyinstaller.org/. In my case and because of the context of my project I choose Ruby 1.8.7.

The installation was very straightforward: accept the license, ensure to check the “Add Ruby executables to your PATH” option and press install.

After a couple a seconds the following screen displayed telling that the installation was completed.

The next component to install was the DevKit, a set of tools to allow the usage of C-native features in Ruby. The installation of this component was not so straighforward, I had to follow the instructions detailed here: https://github.com/oneclick/rubyinstaller/wiki/Development-Kit.

With this, we can say that the base infrastructure is ready, but it is not enough to develop applications. We will need to install gems (this is name given to Ruby packages). To install gems we can use RubyGems package manager that comes with Ruby installation. To use it, just open a Commmand Prompt and type the command to execute. In my case case I installed some tools that I already new I wanted to use:

• Sinatra: a DSL tools to create web applications
• Data Mapper: a persistence framework
• Bundler: a tool to manage application dependencies
• Heroku gem: a package to interact with Heroku platform

To install all this gems, just execute the following script:

gem install sinatra
gem install data-mapper
gem install bundler
gem install heroku

If while installing any of these gems you get an error telling “invalid date format in specification”, you will have to go to follow these steps:

1. Go to <ruby folder>\lib\ruby\gems\1.8\specifications.
2. Find the file mentioned in the error and open it.
3. Look for a line assigning a date, something like s.date = %q{2011-08-17 00:00:00.000000000Z}
4. Modify that line and remove the time s.date = %q{2011-08-17}
5. Save the file and you are ready.

Well folks, that’s all, you are almost ready to start working. I say almost because you may want to install an IDE. But that will be the topic of another post.

To be continue….

To analyze these two situations let’s suppose we need to implement an alerts module to check for alerts provided by a remote service. This new module depends on a integer parameter that sets the interval the alert service will be checked. This parameter cannot be modified by the user. What the user can decide is to enable or disable the alerts module while running the application.

So, we will create a new module following RCE architecture (that is based on Prism) and we will add our new module to the ModuleCatalag in the shell project.

To manage the interval parameter, we will add a new entry in the Settings.xml file in the RCE.Web project.

<Parameter Name="AlertsInterval" Value="10000"/>

Then, to access this parameter, we can use the IConfigurationService provided by the RCE.Infrastructure assembly. We just have to declare this interface to be injected by the container into our instance.

public AlertsPresenter(IEventAggregator eventAggregator, IAlertsView view, IAlertService alertService, IConfigurationService configurationService)
{
   int interval = configurationService.GetParameterValueAsInt("AlertsInterval").GetValueOrDefault(1000);
   // perform additional initialization logic here
}

Note that GetParameterValueAsInt is an extension method and to be able to use it, you have to add a using statement for RCE.Infrastructure.

To manage the other parameter that can be modified by the user to enable/disable the module, we should use the settings module, just to be consistent with the application. As it is provided, the settings module was not designed in a extensible way, I mean, if we need to manage a new parameter in the settings view, we have to modify the settings module each time we want to add something new. We could modify the settings module to handle our specific parameters, but instead of that we will modify the settings module to make it more flexible and avoid future modifications.

We will start by adding a new Region inside the Settings view, to allow each new module to add its own settings view. To do this, we have to include the following declaration at the beginning of the file SettingsView.xaml file.

<UserControl xmlns:input="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Input.Toolkit"&nbsp; x:Class="RCE.Modules.Settings.SettingsView" xmlns=<a href="http://schemas.microsoft.com/winfx/2006/xaml/presentation">http://schemas.microsoft.com/winfx/2006/xaml/presentation</a> xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"&nbsp; xmlns:d="http://schemas.microsoft.com/expression/blend/2008"&nbsp; xmlns:mc=<a href="http://schemas.openxmlformats.org/markup-compatibility/2006">http://schemas.openxmlformats.org/markup-compatibility/2006</a>&nbsp; xmlns:Regions="clr-namespace:Microsoft.Practices.Composite.Presentation.Regions;assembly=Microsoft.Practices.Composite.Presentation" mc:Ignorable="d" xmlns:Commands="clr-namespace:Microsoft.Practices.Composite.Presentation.Commands;assembly=Microsoft.Practices.Composite.Presentation" xmlns:Interactivity="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity" <br>xmlns:Behaviors="clr-namespace:RCE.Modules.Settings.Behaviors" BorderThickness="0" d:DesignHeight="926">

Then, we need to add a new row to the container Grid

<RowDefinition Height="80"/>

Finally, we add the new region in the new row at the end of the file.

 <Border Grid.Column="0" Grid.Row="14" Background="{StaticResource ComboBrush}" CornerRadius="8,8,8,8" Grid.ColumnSpan="2" HorizontalAlignment="Center" Width="350" VerticalAlignment="Center" Height="85" Style="{StaticResource SharedBorderStyle}">
  <ItemsControl Regions:RegionManager.RegionName="ExtendedSettingsRegion" /></Border>

Now, we need to add the ExtendedSettingsRegion region to the RegionNames class in the RCE.Infrastructure project.

public const string ExtendedSettingsRegion = "ExtendedSettingsRegion";

At this point, if we run the application, we will see the following Settings view.

Now, each new module should define a view to be loaded in the ExtendedSettingsRegion (of course it is not mandatory, it is just in case the module requires to manage settings). In the case of our AlertsModule we have just 3 visual controls, a textblock, a check box and a button.

<UserControl x:Class="RCE.Modules.SWUAlerts.Views.AlertsSettingsView" xmlns=<a href="http://schemas.microsoft.com/winfx/2006/xaml/presentation">http://schemas.microsoft.com/winfx/2006/xaml/presentation</a> xmlns:x=<a href="http://schemas.microsoft.com/winfx/2006/xaml">http://schemas.microsoft.com/winfx/2006/xaml</a> xmlns:d="http://schemas.microsoft.com/expression/blend/2008"&nbsp;&nbsp;&nbsp;&nbsp; xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"&nbsp;&nbsp;&nbsp;&nbsp; xmlns:Commands="clr-namespace:Microsoft.Practices.Composite.Presentation.Commands;assembly=Microsoft.Practices.Composite.Presentation"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; mc:Ignorable="d"&gt;&nbsp;&nbsp;&nbsp;&nbsp; &lt;Grid&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;Grid.ColumnDefinitions&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;ColumnDefinition Width="0.5*"/&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;ColumnDefinition Width="0.5*"/&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/Grid.ColumnDefinitions&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;Grid.RowDefinitions&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;RowDefinition Height="0.5*"/&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;RowDefinition Height="0.5*"/&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/Grid.RowDefinitions&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;TextBlock Grid.Column="0" Grid.Row="0" Text="Alerts enabled" FontWeight="Bold" FontSize="11" Foreground="{StaticResource ForegroundBrush}" VerticalAlignment="Center" HorizontalAlignment="Right" Margin="0,0,5,0"/&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;CheckBox x:Name="AlertsEnabled" Grid.Column="1" Grid.Row="0" IsChecked="{Binding Path=AlertsEnabled, Mode=TwoWay, ValidatesOnExceptions=True, NotifyOnValidationError=True}" VerticalAlignment="Center" />
<Button Grid.Column="1"&nbsp; Grid.Row="1" Content="Apply" Commands:Click.Command="{Binding ApplyAlertsSettignsCommand}" VerticalAlignment="Center" Width="110" Margin="0,0,10,0" Cursor="Hand" HorizontalAlignment="Left" Foreground="{StaticResource ForegroundBrushAlternative}" Background="{StaticResource ToolBarBrush}" Template="{StaticResource SetttingsButtonTemplate}"/></Grid>
</UserControl>;

The other extension point to consider is the persistence of the parameter. The settings module manages the persistence using the configuration service, so we can use it and it will be almost the same we did for the static parameter. We just have to declare the dependency to be injected in the constructor and adding a new entry in the settings file.

public AlertsSettingsPresenter(IAlertsSettingsView view, IConfigurationService configurationService){..}

<Parameter Name="AlertsEnabled" Value="True"/>

And use it when handling the apply event.

public void ApplySettings(object parameter)
{
var valuesToUpdate = new Dictionary<string, string>();
valuesToUpdate.Add("AlertsEnabled", this.AlertsEnabled.ToString
this.configurationService.UpdateParameters(valuesToUpdate);
}

If our module needs to updated itself when a configuration value changes, we could subscribe to the ConfigurationChanged event of the configurationService.

That’s all folks! Let’s do a recap:

• We modified the settings Module to include a new Region (ExtendedSettingsRegion)
• We created a Settings view in our module (AlertsSettingsView)
• We added the the corresponding presenter (AlertsSettingPresenter) to able the update of the parameters

Below is a screenshot of the final project of my module.

TODOs:

The way this solution is implemented requires each module to handle the persistence, I mean, each module has to provide a “save” button and call the configuration service. I think that applying a refactoring this logic could be handled by the settings module, but that is part of another post.

Collision detection is a very common concern in games. It consists on determining whether two objects have come into contact with one another. In games, this is necessary in order to make decisions, for example, in games like Mario Bros., it is important to know whether a Mario has collide with a tortoise or a coin. In order to detect collisions, each object  has a bounding box, that is an approximation of  the object’s surface.

A sprite is a a small bitmap image (or set of images) used to visually represent . Another kind of bitmap is a tile, which is usually used for background maps.

During the drawing process all the sprites and tiles are drawn incrementally into a buffer and then this buffer is dump at once into the low level buffer that will impact on the screen. This technique es called double buffering.

To be continue…