Run… Program

If you enable indexing on your Program Files folders, all your programs will then be available either in the Run dialog or in the Windows 8 start screen.

1. Go to the Control Panel

2. Type in Indexing in the search box

3. Open the Indexing Options dialog

4. Click on Modify and select your Program Files folders

You should then see the folders in the Included Locations list:

Close the Indexing Options window. Once indexing is completed, you can start your programs using the Run dialog.

For example, I can now launch Sublime Text like this:

But did you know?

You can create your own run commands. Here’s an example on how to create a run command for Sublime Text.

1. Open the Run Dialog (Win+R) and type in %windir%
2. Once Windows Explorer is open, select New item > Shortcut in the menu (or right-click somewhere in the blank area)
3. Create the shortcut using the wizard specifying the alias for the run command (e.g. st3)

From now on, you will be able to quickly open your program either by typing the command on the start page (if you’re using Windows 8) or in the Run Dialog.

Run Commands Cheat sheet

This list is intentionally cut down as I don’t think a lot of the other commands are that relevant. If you want a more comprehensive list check out one of these links:
Complete List of Windows 8 Run Commands
Run… Command

Pascal Arnould on Twitter

Another powerful tool in the composition framework is the ContentFactory. This provides methods for registering and getting content based on a contentType string. When getting content, if the contentType is not found in the container, it will try to fallback using substrings of contentType by progressively removing sections after a .

As an example, we might have some serializers that inherit from ISerializer.

We can create a new SerializerFactory that inherits from ContentFactory.

Then we use a custom installer to register the factory as a singleton, and also to register our default content (i.e. the serializers).

We are now able to use the SerializerFactory.GetContentFor(string contentType) method to retrieve our serializers by the name we registered them with:

• SerializerFactory.GetContentFor("Foo") will return FooSerializer
• SerializerFactory.GetContentFor("Foo.Bar") will return FooBarSerializer
• SerializerFactory.GetContentFor("Foo.Bar.Baz") will fallback to contentType of “Foo.Bar” and return FooBarSerializer

In the next post I’ll show you how to get set up with endjin composition framework in an MVC4 / WebAPI application.

@MikeLarah

In the software business, historically, we’ve kind of got away with assuming that everything is going to work fine. Resources are ‘just there’ when we ask for them. They don’t mysteriously disappear only to  reappear a moment later. Tasks complete if you set them going…

Of course, that was never really true before, and the unreality of that attitude is all the more obvious when dealing with cloud services.  Here resources really can be temporarily missing, refused or moved. Tasks may begin and never complete because our thread has suspended or died in some virtual infrastructure, only to be resurrected again later.

When we start an operation that may potentially fail, there are a few failure scenarios that could play out:

1) A catastrophic error has occurred, so we want to propagate that exception straight out to the caller

2) A potentially transient error has occurred, so we want to retry the exact same operation again

3) We want to abandon the operation

Abandoning the operation is straightforward. We can use the standard .NET CancellationToken mechanism.

Scenarios 1 and 2 require a Retry mechanism of some kind,

For those, we’ve provided the Endjin Retry Framework. (That link takes you to the nuget package download.) Source code is also available, along with a sample.

Policy

Policies are used to determine whether we should consider retrying at all, given that a particular exception has occurred The default policy is AnyException – you can always retry regardless of the particular exception or its content

We also provide an AggregatePolicy which allows you to retry if and only if all of a set of policies allow you to retry.

It is up to you to write custom policy if you want particular exceptions to be “non-retryable” For example, you might set up a policy that does not allow you to retry if you get a 404 (not found) from an http operation, but does retry if you get a 501 (internal server error). To do this, you implement the  (very simple) IRetryPolicy interface.

Strategy

The strategy determines how a task is retried. There are two phases to this. In the first phase, we prepare to retry given a particular exception, and calculate an optional delay before we retry the operation. In the second phase, the framework checks whether we are allowed to attempt a retry (we haven’t, for example, exceeded some maximum number of retries).

The strategy also aggregates the exceptions that caused us to require a retry attempt, and raises a Retrying event just before a retry attempt occurs.

We provide three strategies in the box:

Count: will retry immediately up to a maximum number of times

Incremental: retries up to a maximum number of times, with an (optionally increasing) delay between retries.

Backoff: is similar to Incremental, but provides an exponentially increasing delay between retries, with a random element.

Note – you don’t want to use the Incremental or BackOff strategies in Windows Azure. It is better to hammer the fabric and let it adapt to your preferred usage pattern.

If you want to implement your own strategy, you inherit from RetryStrategy and override the PrepareToRetry() and CanRetry() methods. Here’s an example.

Scenario One: TPL

If you want to start a new Task using the TPL, but automatically retry that task using our retry framework, we provide a source-compatible replacement for Task<T>.Factory.StartNew() and Task.Factory.StartNew() called RetryTask<T>.Factory.StartNew(), and RetryTask.Factory.StartNew().

Each of the overloads also takes additional optional parameters for the Strategy and Policy, defaulting to AnyException and Count (with a maximum of 5 retries).

Here’s an example of that.

Scenario Two: Async

Sometimes, you are using the async/await pattern and need to call an async method. In that case, you can use our Retriable.RetryAsync() method.

This also works for inline async delegates

Scenario Three: Synchronous

Finally, it works just as well for a synchronous method.

If you’re running a version of Windows on your desktop/laptop, then this is the post for you.

If you’re running a version of Linux on your desktop/laptop, then this is the one you need.

Learning To Program – A Beginners Guide – Part One – Introduction

Installing on Linux is a bit more complicated than installing on Windows. I’m assuming that if you’ve opted for Linux, you’ve got a bit more technical experience. I hope so, or some of this is going to be a bit confusing! I’ve used Ubuntu Linux 12.10 in a default desktop install for these instructions. Your mileage may vary with other flavours. You’ll also need at least 2GB of RAM in the computer, and plenty of free disk space.

To get started, you need to open up a Terminal, which we’re going to use to install some packages to set up our programming environment.

We’re going to use a tool called ‘apt-get’ to pull these packages down, along with a tool called ‘sudo’ to give apt-get permission to make changes to our system as it installs the packages.

At any stage, it is also possible that sudo will ask you for your password to allow the package to be installed. Just check that it is really sudo that is asking, and input your password if required.

The first package to install is Mono Develop. Type the following line, and press enter.

sudo apt-get install mono-devel

A bunch of information will scroll past, and then it will ask: Do you want to continue [Y/n]? Just hit enter (for ‘yes’). It should all install OK, spewing a load of information at you as it does so.

Then, we need the mono compiler (type the line and press enter as before)

sudo apt-get install mono-gmcs

A bunch of information will scroll past, again, before it asks: Do you want to continue [Y/n]? Just hit enter (for ‘yes’). It should all install OK.

We also need a package called autoconf.

sudo apt-get install autoconf

Another bunch of information will scroll past, and then it will ask: Do you want to continue [Y/n]? Hit enter (for ‘yes’) as before to complete installation.

Then there’s a package called libtool

sudo apt-get install libtool

Another bunch of information will scroll past, and then it will ask: Do you want to continue [Y/n]? Hit enter (for ‘yes’) once again, and all should proceed happily.

Still not done. Now we need a package called g++

sudo apt-get install g++

Guess what. It asks: Do you want to continue [Y/n]? Hit enter (for ‘yes’) once again, and all should proceed happily. (You should be pretty familiar with apt-get by now.)

Then, we need to install a package called ‘git’

sudo apt-get install git

Again, a bunch of information will scroll past, and again it will ask: Do you want to continue [Y/n]?. Hit enter (for yes), again.

Now, we’re going to use git to pull down a later version of our Mono runtime (Version 3.0)

git clone https://github.com/mono/mono

You’ll see some progress as it downloads (it will take a few minutes). Once it is down, we need to build and install it. So, switch to the mono directory:

cd mono

Then, we generate the build scripts for mono:

./autogen.sh

(Lots and lots of scrolling information, downloaded packages etc…)

Build mono:

make

(Plenty more of the scrolling text, consuming several more minutes of your life…maybe half an hour or so. Go and get something to drink.)

And install mono:

sudo make install

If that was all OK, we can move back up out of the mono folder.

cd ..

Right. With that done, we’re now going to use git to pull down the F# development tools.

git clone https://github.com/fsharp/fsharp

You’ll see some progress as it downloads. Next, switch to the fsharp directory

cd fsharp

Generate the F# build scripts:

./autogen.sh

(Lots and lots of scrolling information, downloaded packages etc…)

Build F#:

make

(Plenty more of the scrolling text, consuming yet more of your life…maybe another half an hour or so. Perhaps it is time to go and buy some healthy snacks.)

And install F#:

sudo make install

If that was all OK, we can move back up out of the fsharp folder.

cd ..

Now, we can start the interactive fsharp environment.

fsharpi

You should see the F# interactive environment start up as in the image above.

To quit the interactive F# environment, type

#quit;;

Matthew Adams on Twitter

You need to be running Windows 7 or Windows 8 (or later).

If you’re running Windows Vista or Windows XP, I’m sorry, but this isn’t going to work for you.

First, we need to make sure that the .NET Framework V4.5 is installed.

If you happen to have installed Visual Studio 2012, then you’ve got it already.

If you are running Windows 8, then you’ve got it already.

If you are running Windows 7, then go to this link to download and run the .NET V4.5 installer.

http://go.microsoft.com/?linkid=9810134

Follow the instructions in the wizard to get .NET installed on your operating system. This may require a reboot.

Next, we have to install the Windows SDK.

If you have installed Visual Studio 2012, then you’ve got it already.

If you are running Windows 8, you need the Windows 8 SDK

Go to the Windows 8 SDK download page:

Find the download button and run the installer. Follow the instructions in the Wizard to install the SDK with the default options.

If you are running Windows 7, you need the Windows 7 SDK

Go to the Windows 7 SDK download page:

Find the download button, and run the installer. Follow the instructions in the Wizard to install the SDK with the default options.

Next, we can install the F# Runtime environment and tools.

Download and run the F# tools from here.

Agree to the license, and click next. The tools will be setup for you.

Once you’ve done that, the tools are on your computer, but getting at them is a bit tricky!

To make things easier, we need to add the Fsharp tools to our environment PATH.

Open up a Windows Explorer window, and find Computer. Right click it and choose ‘Properties’.

This opens the system properties Window (the picture is of the Windows 8 version, but Windows 7 is very similar).

First take note of whether you are running a 32bit or 64bit operating system, this will be important in a minute.

Then, on the left hand side of the window, click ‘Advanced System Settings’.

This pops open the System Properties Dialog. Click ‘Environment Variables’

This opens the Environment Variables window. In the ‘System Variables’ section, scroll down until you can see the ‘Path’ item, and select it. Then click the ‘Edit’ button.

This opens the Edit window.

Put the cursor at the end of the ‘Variable Value’ text field and type a semi-colon to separate this new path from the next one:

;

Then add the path to the directory where the F# tools were installed:

If you have a standard 32bit installation of Windows 7, this will be

C:\Program Files\Microsoft SDKs\F#\3.0\Framework\v4.0

If you have a standard 64bit installation of Windows 7 or Windows 8, this will be

C:\Program Files (x86)\Microsoft SDKs\F#\3.0\Framework\v4.0

Now, click ‘OK’ to close the ‘Edit System Variable’ window, ‘OK’ again to close the ‘Environment Variables’ window, and ‘OK’ again to close the ‘System Properties’ window.

You can then start a command prompt:

On Windows 8 go to the start screen and start typing

cmd

make sure Command Prompt is highlighted and press enter (or click it)

On Windows 7 click the start button and type

cmd

make sure Command Prompt is highlighted and press enter (or click it)

Finally, we can check that the environment is installed correctly.

To start the interactive F# environment, just type

fsi

You should see the F# interactive command prompt.

To quit, type

#quit;;

Matthew Adams on Twitter

Gotcha #1: Activation

If you follow the installation guide for Mac, one of the step covers activation: “As you start developing, you will be asked to activate your installation”. What it actually means is that you have to fire up Xamarin Studio, create a new project and start building it. Only then will you see the activation dialog:

Create a new iOS solution

Activation dialog

What caught me is that I proceeded with the Windows installation on my VM to enable Visual Studio integration before activating it on the Mac ‘side’. Trying to run an iPhone project inside VS 2012 obviously threw an activation error and I naturally looked for a way to activate the install from within Xamarin Studio; something like an ‘Activate’ button. There isn’t! I’m not sure why activation doesn’t take place while running the installer but it would be useful to have at least the option to register the product from the menu bar like so many other products do.

Gotcha #2: Application Properties

With everything activated, I then decided to test my setup by running Tasky, a sample application provided by Xamarin. Unfortunately the iPhone simulator would simply quit on start with little indication as to what cause the crash.

Error: “The simulated application quit.”

After a bit of googling around, this thread on the Xamarin forum provided the solution. What solved it for me was to first delete the ~/Library/Application Support/iPhone Simulator directory on my Mac. Then going back to Visual Studio, I went into the project properties and checked that the fields highlighted in red were filled correctly.

Tasky running in the simulator:

Gotcha #3: Profiles

If you are going to use MvvmCross, an MVVM framework for Xamarin that relies on the PCL (Portable Class Library) at its core, you have to, at least for now, setup the correct framework profiles for developing Android apps with Visual Studio and Xamarin. Further details and the files can be found in this post from Stuart Lodge.

Once you’ve copied the required files, you can start a new PCL project that will be reusable across platforms.

Before creating the project, Visual Studio will prompt you for the target frameworks. As you can see from the screenshot below, the “Mono for Android” and “MonoTouch” frameworks are now available.

When I selected one of the Mono frameworks, I got this warning:

I initially thought something was wrong with my setup but quickly realised that the answer is simply to pick the correct WP version:

So apart from the few niggly issues above, the rest was rather painless. Everything ran smoothly on the day and I am now all set for some mobile dev.

Pascal Arnould on Twitter

Firstly, we define an interface for some type

Then, we create a concrete type for our interface

Now we can use one the composition framework’s convention based installers. For instance we could use the namespace installer, to install all types in a given namespace into the container.

The namespace installer will register types against their Default interface – where the default interface is the interface that follows the naming convention I + [my specific name] + [service name] (e.g. the default interface for class FooBarService : IFooService, IFooBarService is IFooBarService)

Most of the convention-based installers will install the concrete type into the container as Transient by default, but we can explicit specify the lifestyle using [Singleton] and [Transient] attributes.

See the Installers page on the GitHub wiki for a complete list of all the installers included in the framework, and explanations of how they work.

Next step is to initialize the container within our application’s start-up code. This is done using the Bootstrapper appropriate for whichever framework we are using, which will locate the installers in our assemblies and install the types they find into the container.

WP8

WinRT

.NET 4.0/4.5

You can now use the static ApplicationServiceLocator.Container for resolving your root types.

In the next post, I’ll go over how to use the ContentFactory for registering content with custom names.

@MikeLarah

Programming, like most crafts, is the process of taking one thing and turning it into another thing. Turn a touch on a screen into a character in a message, or a tap on controller into the sideways shuffle of a character in a game. Simple to describe, they’re actually quite complicated to achieve, involving many thousands (or even millions!) of such processes, all chained together.

The Art of Programming is breaking those big problems down into ever smaller chunks, organizing them so that we can keep them in our heads without going crazy, and recognizing patterns that we can apply again and again to solve the same kinds of problems.

Being a programmer is quite new, as crafts go. If you worked in wood, or metal, you’d have thousands of years of experience to draw on. Most of the tools we use today would be recognizable to people working 1,000 years ago – albeit that they are often now computer controlled and operating unimaginably more quickly, and reproducibly.

But our craft, give or take some early precursors, is only about 70 years old. Not only are the tools (the programming languages and environments) still developing, but the raw materials we’re working with (computers, sensors and output devices) are evolving all the time. It’s rather like the copper age, bronze age, iron age and the invention of steel and modern alloys all happened in a single lifetime, and we’re still racing to keep up.

So it can all be rather confusing.

The great Medieval Cathedrals in Europe were built by craftsmen. They used their experience, guile and a fair slice of dumb luck to build awe-inspiring edifices, most of which have stood the test of time. Admittedly, some have collapsed spectacularly, and bits have fallen off other ones, or the roofs have caved in, and they’ve need centuries of botching and buttressing and patching. But they’re still there.

We don’t build spectacular architecture in that way anymore. Scientists have worked out a load of really useful theory that helps us to understand the forces involved, model them, and allow the current generation of craftspeople to design and construct buildings that look almost impossible to us, let alone those medieval cathedral guys.

A computer programmer today is rather like one of those medieval craftsmen. We build incredible things through experience, guile and a fair slice of dumb luck, but sometimes things collapse spectacularly, bits fall off, and they almost always need constant botching and patching to keep them running.

A few people come to computer programming through an academic Computer Science route at University. Many more are drawn this way through happy accident, and there is a definite divide between the Scientists and the Craftspeople. We’re going to try to close up that divide a bit, and learn a bit of the science that underpins our craft as we go along, in an effort to be more like a modern architect than a medieval one.

Computer Science is a very important discipline, closely related to Mathematics, and responsible for the fundamental advances in our subject from the first ideas of computability (we’ll come on to that later), to stored program computers (like the one in front of you), to many of the programming languages, tools and algorithms (we’ll come onto those too) we use today.

If you want to learn the craft of computer programming you don’t have to be a computer scientist, or an awesome maths whizz, but you are going to end up learning a fair slug of maths along the way – at least, some particular bits of it. If you’re interested in computer graphics, even more so (who’d've thought all that trigonometry was going to be useful?)

In this series, we’re going to assume that you’ve got some basic high school maths. You’re comfortable with addition, multiplication and division, squaring numbers, and calculating percentages; and can, if you’re forced to, remember (or look up) how to do things like long division by hand. If you’re OK with that stuff, you’ve got the fundamental apparatus to start thinking like a programmer. Even if you’re not super-confident don’t worry! We’ll be taking it slowly and explaining everything as we go.

If all that maths talk was scary and baffling and reminds you of your most hated hours at school, take a deep breath. That’s your teacher’s fault, not yours (well, maybe you contributed a bit if you were as sulky a teenager as I was). Remember: it’s never too late! If you’re interested in programming, I’d go and learn a bit of basic maths over here where it is safe and friendly, practice a bit, then come back here in a week if you’ve still got the bug!

The other thing is that we’re not going to be able to leap straight from a standing start to the programming equivalent of a Cathedral. We’re going to have a series of very small triumphs that, eventually, will lead to something like a modest garden outbuilding.

We’ll slave away for a few hours or days or weeks, and learn something new. We’ll know it is a huge achievement, but when we show it to our husband or housemate or colleague, the best we can hope for (if they really like us) is that they’ll stifle their yawn and not make too derisive a snorting noise as you point at the number ’3′ which has appeared somewhere on the screen along with a load of seemingly unintelligible bafflegab.

The important thing is that we know that it is a breakthrough, and another bit of our craft mastered. That’s what really matters. It’s going to be hard work, but that’s what makes it satisfying.

Ok, there’s one more prerequisite.

I’m going to assume that you’ve got a computer or laptop of some kind that runs a traditional ‘desktop’ operating system. Either Windows 7 or 8, MacOS X, or a popular flavour of Linux. And that you know how to find files, install software and so forth on your preferred computer. Again, you don’t have to be a total wizard because we’ll show you a screenshot/walkthrough of the setup we have to do to be able to start programming, and check it is all OK as we go on, but it’ll help if you know how to use the file explorer/finder and do basic housekeeping tasks.

In the next couple of posts, we’re going to set up the tools that we’re going to use in the rest of this course on Windows or Linux.

Learning To Program – A Beginners Guide – Part Two

Matthew Adams on Twitter

There are a few reasons we decided to take this step. Mainly, we were developing some early Windows Phone 8 and Windows 8 applications last year, like our cross-platform charting controls and Milliman’s Azure Compute Dashboard, and we couldn’t live without DI. At the time, none of the existing container frameworks supported all the main Microsoft platforms that we were working with, so we had to “roll our own”. I did attempt to build a Windows 8 Azure Dashboard app (see pic) without DI to begin with, but the barrier to maintainability meant when it got large enough I ended up pretty much going back to the start and reimplementing it using our new framework.

Other containers are also really expensive for a ‘miss’ scenario (i.e. trying to resolve a component that isn’t registered in the container), because they use exceptions to implement this. We wanted to be really efficient for failing to find a match so we could implement an inexpensive “fallback mechanism” (e.g. looking in the container for handlers for specific content types, falling back to more general versions, if they were not found).

The other reason was, as much as we love Castle Windsor, it does a lot (much like the Spring Framework in the Java ecosystem). It suffers from a problem that many OSS projects do – it’s based on contributions from the community but rarely do people rationalise and prune the feature set. So with our container, we’ve stripped it back and included only the features we require. This means that there’s lots it doesn’t do, but in this series of blog posts, we’re going to cover many of the main usage scenarios.

Whatever the framework, component composition works the same way: you have contracts and concrete implementations and you need to map one against the other. The Endjin Composition Framework helps you work smarter, not harder by making component composition simple.

You can install the packages via NuGet or the source code is available up on the endjin GitHub page. There are packages for use with .NET 4.0, .NET 4.5, WinRT and Windows Phone 8 frameworks. Additionally there is an Endjin.Core.Composition.Web package with extensions for use in ASP.NET MVC 4 / WebAPI applications.

There are samples in the GitHub repo for how to use component composition for each of the supported frameworks, and in the next post I’ll go over how to get set up.

@MikeLarah