7

While this blog post is more personal than the average posts on this blog, I'm posting it as it's impossible that what happened to my family won't have an impact on my level of commitment to the Umbraco project in the near future.

Yesterday August - my seven year lovely first born son - was diagnosed with Diabetes Type 1. He's ok. I'm lucky to live in a country with amazing health care and near a hospital with amazing knowledge on the subject. He's the most brave person I've met and thank god he doesn't appear to have inherited his father's fear of needles. Something which is clever when he'll need to prick himself more than ten times a day for the rest of his life.

As a parent there's a lot to learn in very little time. This means that August will naturally be my (almost) only concern in the next few weeks where my wife and I are given intense instructions on diabetes by doctors, dieticians, psychologists and other experts that I've been shaken hands with the past 24 hours but yet to remember what role they had. As crazy as it may sound, I've felt blessed numerous times of living in a country where I'm given these opportunities. I know that I'm more lucky than the average parent of a child with diabetes.

The side effect is naturally that my evolvement with Umbraco will be at an all time low. However, I feel blessed again. Even though there's never a good timing for an event like this, the project is at a stage where I'm not indispensable. The core team knows v5 better than I do, work is being done on getting 4.7.1 out of the door (albeit delayed until coming weeks), my wonderful coworkers at HQ (the Umbraco company) knows how to run it without me and the community ethos is stronger than ever.

So this doesn't mean that I'll go away - after all the Umbraco community is my second family. Please take as good care of it as I'll do of my number one in the coming weeks and months.

Love,
Niels…

When Alex, Shannon and myself were putting together the list of Umbraco 5 Gems for the CodeGarden 11 talk we had to make a decision about what we would and what we wouldn't be able to cover. Since we only had an hour and there are so many awesome hidden gems in Umbraco 5 there was a number of things that simply didn't make it into the presentation.

In this final part of the series we're going to have a look at the remaining Gems, the last of the cool features from the Umbraco 5 CTP (but not the last of the cool features for Umbraco 5!)

Bendy Objects

In Umbraco 5 we're making quite extensive use of dynamic objects to make it easier for people to work with the data that is being generated from the Umbraco database, similar to the idea of DynamicNode in Umbraco 4. But we realised that we needed a much more powerful way that you could deal with dynamic objects and more importantly, dynamic object graphs.
This is where Bendy comes in, the idea of Bendy (and in turn Bendy Objects) is that you can turn any object, or any object graph, into a dynamic object. With Bendy you can either make the objects dynamic typed and use 'dot-notation' (entity.SomeProperty) to access the data stored by that entity for a property or you can use it like an indexer (entity["SomeProperty"]). What is also really cool about Bendy is that is all lazy loaded so if you never access a particular property the data will never be produced, and the same goes for children and parent objects. This gives us high performance within the API itself.
Expect to see more on Bendy as tutorials come out around working with Umbraco 5 data.

WriteLockDisposable

Dealing with shared memory resources in multi-threaded applications can be a bit of a pain and your only safe bet is to use double lock checking. With some improvements that have come as part of .NET 4.0 we've been able to make this a bit simpler for developers through a custom API we're exposing called WriteLockDisposable. Essentially this creates a disposable object which you can then use yourself to create singleton objects and not worry about having thread locks occurring from accessing shared resources.

Mandate API

How many times have you written a check for an ArgumentNullException, how about a generic ArgumentException? This is something we do a lot in Umbraco 5. And I mean a lot!
Since we wanted a way which we could easily do the check in the same way everywhere we've created an API which is named Mandate. You use Mandate like saying Mandate.That(boolean, "message when failing") and we'll handle the rest. We're even going to support localizing the exception messages using the awesome new localization framework. Mandate can be used for null checking or boolean condition checking, giving a clean and common way to do error raising.

DisposableTimer

Anyone who has tried debugging an internal error of Umbraco 4 will know just how hard it can be and when something breaks internally it's very hard to describe to someone else. To address this with Umbraco 5 there is a new API which is used to manage the tracking of information when something internally is happening. When you spin up a DisposableTimer a log message starts then you can use the logging API add your own messages before the DisposableTimer is disposed of. This means you can see what happens between the start and finish making it very easy to see the what happened in a particular scope.

Logging

As mentioned above we have a DiposableTimer in Umbraco 5 which will help tracing what happens in a particular scope block which you can do your own logging in. For logging we've gone with log4net which is a very popular .NET logging API. To make it simpler to work with we expose a LogHelper class which will help you get the appropriate logger for your type.
Another really good feature of log4net is that through its powerful configuration system we can control the logging very finely, so when you deploy to a production server you can dial back the logging to a minimal. If an error is happening in a specific section of the application you can enable deeper logging for that section than the rest of the site, etc.
Hopefully this means that finding errors within the core of Umbraco 5 itself a lot easier.

Simplifying LINQ with QueryDescription

For a Hive Provider the ability to query is quite important and the obvious query API is LINQ. The problem with LINQ (well with Expression Trees actually) is that they are very complex and to create your own custom provider that will be able to process an Expression Tree into something that you can understand in your provider is really quite complex.
In an effort to make it simpler for people to create their own Hive Provider and have it queryable we've created an API in Umbraco 5 called QueryDescription so rather than receiving the Expression Tree in its raw form Umbraco 5 will parse it into a QueryDescription which you can then consume in a much simpler manner.
This will give the power of LINQ to consumers of Hive Providers yet a simple API to handle as a Hive Provider implementer.

PreValue's are overridable

Something we've noticed with the way users were using Property Editors which had PreValues in Umbraco 4 was that the same Property Editor would be used on multiple Data Types with only a change to a PreValue or two. With Umbraco 5 we've decided to make this a bit easier, rather than having to create multiple Data Types to change a single PreValue you'll be able to override the PreValue properties on the Document Type. This means that you can create a Data Type which is your standard way with standard PreValues, but on a special case you can change it to what's needed.
The advantage of doing this is that if you want to create a larger change to a Data Type you'll be able to do that in a single place, rather than across multiple Data Types.

Examine is BACK

Examine the Lucene.Net search API which has been included since Umbraco 4.5 will be making a return in Umbraco 5 but it's getting a face lift. Instead of being an external API which has its own query manner and such the new Examine version (ingeniously named Examine 2) will be an Umbraco 5 Hive Provider. Something that we've been stressing in this blog series (and the Umbraco 5 Hive talks) is that the Hive isn't just about Nodes and Examine will be living proof of this.
Additionally Examine will be taking a larger role in the way data is handled in Umbraco 5, rather than being the primary Lucene.Net API we're going to be providing a fast-read API to serving out the published content in Umbraco, a new API powered by Examine.
And after all Examine 2 is just a Hive Provider so why couldn't it be used in such a way to make the published content even faster?

Providing functionality to pages

In Umbraco 4 you can put your own functionality behind a template by creating a custom base type that the template inherits from. With Umbraco 5 we wanted to offer similar capabilities but in a MVC way, this means that we need to ensure that if you want to create a Controller and Action then you can.
Well the good news that this will be possible in Umbraco 5, allowing you to use the skills from standard ASP.NET MVC3 development for the most part. Rather than looking at the URL to get the Controller and Action Umbraco 5 will look to the Document Type Alias and Template Name. So if you have a Document Type with the alias textPage you can create a Controller named TextPageController. Immediately the Umbraco 5 rendering engine will redirect all requests through the Index Action (assuming it exists), allowing you to provide global changes to any page using that Document Type. If you want to take it one step further you can then create an Action on the Controller which has the same name as a template, say Content (for the content template) which you then have control over just that particular Document Type and Template combination. This opens up a world of possibilities to say return JSON from a Template rather than HTML but influencing the Action Result returned from the Action.
Powerful huh!

And now we are at the end of our Umbraco 5 Gems series. We hope that you've enjoyed reading about some of the more hidden and unusual aspects of Umbraco 5 and can't want to get cracking with it.

The last part of the Umbraco 5 Gems talk at CodeGarden 11 was to look at some of the more crazy aspects of Umbraco 5, the stuff that you'll want to know if you're delving deeply into the API and really wanting to extend Umbraco beyond the needs of the average user.
 

IoC is swappable

We've decided that Autofac will be our IoC (Inversion of Control) container of choice, but that doesn't mean that it suits everyone. As a developer you might already have a stack that relies on another library such as NInject or Windsor, or your team is just more comfortable with one of the other DI containers available.
With the way the Umbraco 5's IoC is designed it will be possible for you to use another IoC container without having to hack into the core of Umbraco, instead there will be a few interfaces and classes to implement which will provide all the hooks into Umbraco. Internally all of v5's dependency registrations are done against our abstraction layer meaning as soon as you plug in your library of choice, our registrations will still end up in your container for you to interact with or have our components injected into yours.
 

Abstract task system / loosely-coupled events bus

In Umbraco 4 events are strongly typed against the various .NET types within Umbraco, using the standard .NET event system. In an application the size and complexity of Umbraco standard .NET events can be a bit restricting, so instead for Umbraco 5 we're going with a loosely coupled task system in which events are raised into an application-wide task manager based on pre-defined trigger names.
To listen for a task you simply hook your code up with a trigger name similar to a regular .NET event, or add a Task to your plugin assembly decorated with the appropriate attribute, and our task manager will execute it when the relevant trigger is fired, meaning you don't have to connect directly to a particular object instance. Tasks are also chainable so you can cancel proceeding tasks or pass information back to the caller or the next task in the queue.
It also means that a task with a particular name can be raised from various locations within the application - even your own plugins.
This disconnected task system means that we can have much greater flexibility than standard .NET events.
 

File system is a Hive provider

Like everything in Umbraco 5 we have a Hive provider for the file system. Files such as CSS, JavaScript, Templates, etc are loaded through the Hive. Out of the box this will be loading off your hard drive, but it does mean that we have a lot of interesting options. Since we abstract away the file system you can swap the file system out for a Hive provider for one which reads out of a database?
Or out of cloud storage like Azure?
This means that you can leverage the power of a CDN to serve out your common assets and increase the scalability of your Umbraco 5 website.
 

Drumroll... Umbraco Application Framework is separate from the CMS

Since there's lot of cool features and reusable classes in Umbraco 5 which don't require a web UI, or any UI for that matter, we've made a deliberate separation between the Application Framework and CMS projects and because of this you can use them without the CMS product itself.
In fact the CMS is just a product which has been built on top of the Umbraco Application Framework.
So in your own application you can leverage APIs such as the Hive, Localization or the task system.

So this wraps up the list of Umbraco 5 Gems from the CodeGarden 11 talk but as it turns out there was way too many Gems to cover in a single hour so keep an eye out for the next post on the Umbraco 5 Gems we haven't previously spoken about!

On thursday July 13th at 12:00 GMT+1 we will start upgrading umbraco.com as part of a bigger maintance job on our internal systems.

It means that umbraco.com will be inaccessible for most of an hour, including any licenses, invoices, or downloads you might want to access from umbraco.com

our.umbraco.org and the umbraco deli will not be affected by this maintance and will stay online.

Sorry for the inconvenience, we'll try to get the site back online as fast as possible.

UPDATE: we're back, took 20 minutes longer then expected, and we hit a tiny hiccup with license downloads. If you find any issues with the site, please post a comment to this post or use our standard contact forms, we're keeping an eye on the site, but everything seems to be running smoothly

Another day and another Umbraco 5 Gems post is available. Today we'll be looking at what Gems there are for Developers with the Umbraco 5 release.
Umbraco has a great history of being highly flexible for people who want to extend it beyond just a simple CMS. In this article we're going to dive how we're making the CMS even easier to extend than before from the point of view of a developer working with the API or a developer wanting to create packages.
 

Searchable trees

Umbraco has had back office searching through a search box in the upper left corner of the content application, but the problem was it was limited and hard to plug your own trees into. If you wanted to have searching for your own back office application then you had to go about doing it as a dashboard application. While this is good (and still do-able in Umbraco 5) it did mean that you didn't have the ability to leverage the built-in UI of Umbraco.
Well with Umbraco 5 this has been addressed with a new interface, ISearchableTree. When implementing this interface whilst putting together your own tree, you'll be able to hook into the Umbraco UI for searching. What's really cool is that this is contextual, so if you create a custom tree which is loaded into an existing application, e.g. for content, searching will be targeted against that automatically.

The data layer is a Hive of activity, and the default content provider is NHibernate 3

Data in Umbraco 5 is the epitome of pluggable, and you can even merge multiple providers into one website. The primary, out-of-the-box provider for content, media, etc. in Umbraco 5 will be NHibernate (with Fluent NHibernate to make the mappings more robust). This means that there's no more embedded SQL, instead we can leverage the testability of an ORM. This also means that we can maintain our support for Microsoft SQL Server (including CE4) and MySQL.
It also means we're going to be having proper transactional data interaction so it'll be a lot harder to get yourself into a state where the Umbraco database is corrupt.
Hive is not just about traditional "database" data either: you can use it to plug in your own data for powering content, but we also use it for things like files meaning cloud storage feels no different to native storage, you simply swap out the provider in config. There are more details in Alex's talk from CodeGarden11.
 

Hive ID's are URLs

To tie in with the Hive in Umbraco 5 we've changed the ID scheme to not be just a number. This means we're able to store more information in the ID, and in fact the Hive will store two additional pieces of information, the "item type" e.g. content / media, and the provider.
The reason this is powerful is that because we're able to have different Hive providers listen for the URL scheme, and load the data from a different provider depending on the route or other rules.
In fact the different files in the application (CSS, JavaScript, DocType Icons, etc) are all loaded from a single Hive provider with different instances listening for different URL schemes, the CSS provider listens for storage://stylesheets where as JavaScript is storage://javascript, and so on. Even the "file upload" property editor uses Hive, but more on why that is awesome in a future post.
 

Simpler back office applications and trees

One thing we got from talking to package developers was that creating back office applications and trees could be quite tricky and even getting your own tree into an existing back office application could be difficult. In Umbraco 5 this has been changed so that it wont require these to be kept in the database, instead they are kept in the config. So with a simple change to config you'll be able to create a new application, move trees between applications, etc. Also these config options will be specific to your plugin so you don't need to worry about updating a global config file somewhere (more on Umbraco 5 configs below).
Additionally these will have an immediate effect on Umbraco so you don't have to log out or restart IIS (and t here's a really sexy little animation which you'll see to refresh the application icons!).
 

Plugins are not loaded into the /bin

When you've got an Umbraco site with many different extensions it's possible that you'll have a lot of assemblies in your /bin folder, but how can you keep track of what files belong to what package?
Again in Umbraco 5 we've decided to address this and in doing so we have elected to store plugin assemblies separately, in the plugin directory itself - and since each plugin is in its own folder, it'll be a lot easier to work out exactly what belongs to what files belong to what plugin.
Again to learn more about the v5 plugins I suggest you check out Shannon's talk.
 

Plugins use NuGet

Rather than maintaining our own plugin XML format we've decided to go with NuGet as our packaging format. NuGet is perfect for packaging since it has all the information we need for a plugin, a name, id, version, license URL, etc.
There is even a simple to use desktop tool (and command line) which will mean you'll be able to create packages from within the Umbraco UI and from outside the Umbraco UI.
Please note that in the CTP you're unable to create packages from the Umbraco UI, instead you need to use the NuGet desktop application. There's a good amount of information on the NuGet website which covers what NuGet is in more details and even a walk-through of how to create a NuGet package using the desktop application. There are a few differences though and again I suggest you refer to Shannon's talk for more about plugins in Umbraco 5.
 

Simplified configs

When we were speaking to package developers one of the primary things that they use the Package Actions in Umbraco 4 is to manage changing the configs for Umbraco. So a big goal of v5 was to make it easier for package developers to provide configuration information to Umbraco from a package without worrying about modifying the web.config of the website.
Since each plugin is in its own folder it also has its own config. When Umbraco 5 starts up it will parse all the configs for all the packages and produce a large view of the config state of the application. In addition all the configs will be loaded in a last-in order, so if you want to override something within either the root Umbraco config, or in another package, you will be able to. And when you uninstall a package the config will be removed too, rolling back to a pre-installed state.
This is known as the Deep Config Manager and it is responsible for the whole Umbraco 5 config. And don't worry, it still supports both app-settings and custom config sections depending on your personal preference.

So this brings us to the end of another Umbraco 5 Gems blog post. Hopefully some of the changes we've got around making Umbraco 5 an amazing development platform are tantalising for application and package developers. Stay tuned though, we've got more Umbraco 5 Gems to come.

Continuing our theme of Umbraco 5 Gems we've decided that today we'll look at the Gems for ASP.NET MVC developers and we've got some really handy ways which you'll be able to hook into MVC. Additionally this means that your existing MVC skills will be usable when developing with Umbraco 5. It also means that a lot of the skills you can gain from MVC tutorials will be usable in Umbraco 5.
 

Convention over Configuration

One idea that MVC touts is the idea of Convention over Configuration, particularly with the way that it lays out its project. An MVC project will have folders such as Content (containing CSS, Assets, etc), Scripts (for JavaScript) and Views (for HTML) and with Umbraco 5 we're keeping these folders and using them to store the files which you'll use in Umbraco sites.
Plugins will also use those folders.
 

Global ActionFilters

MVC has the concept of Global ActionFilters which allow you to interact with the pipeline and are used for things such as handling errors. But it does mean that you can use them to extend or interact with the internals of Umbraco without having to modify the core .NET code.
 

Knockout JS

If you haven't looked into Knockout JS I suggest you go do that now! It's awesome.
With Umbraco 5 we're using Knockout quite extensively to handle the back office UI state, everything from DocType editing to CSS editing. This is exciting as it means we'll be shipping Knockout out of the box with Umbraco so you'll be able to use it yourself to create powerful back office UIs.
 

Embedded Views

Sometimes package developers (and the Umbraco core) want to ship only a single file as part of their package. With Umbraco 5 we're supporting a way which you can turn the Razor view file into an embedded resource in your assembly. This means that if you don't want your HTML available to be edited it can be neatly rolled up into something that other developers are unable to get to.

And this wraps up part 2 of our Umbraco 5 Gems series. Hopefully this gives you some cool insights into what's coming for Umbraco 5 that you can use your existing ASP.Net MVC skills with. Stay tuned for more v5 Gem goodness!

At code garden this year Alex, Shannon and I talked about some of the hidden gems which are being included in version 5 of Umbraco.
Well not every feature was able to be given the credit it deserved in the talk (also after the fact we realized we missed some too!) so we said that we'd produce a series of blog posts which will look at some of the features in more depth. Over this series of posts we're going to look at Umbraco 5 Gems from the perspective of difference kinds of people who use Umbraco because there are lots of different kinds of Umbraco users and not everything will be logical for them. Also to include everything in a single post would make for a really huge post!
 
First up we're going to look at some Umbraco 5 Gems for Content Editors.

It looks the same

Although not really a Gem in itself this is something that we really want to stress about Umbraco 5, that we're keeping the same Umbraco look and feel from a user point of view for Umbraco 5. That's not to say it'll be a 100% skin copy of Umbraco 4, expect some improvements and more polish (because after all the web has evolved a lot since the first Umbraco back office UI was done) but the concepts that editors have grown to know and love will still be retained. This means that it's not a case of re-skilling Content Editors upon the release of Umbraco 5.

Drag and drop DocType properties and tabs

This is a feature you won't know about until you come across it and once you find it you'll wonder how you lived without it. Simply put, Shannon realized that it was a pain to move a property between tabs when editing a DocType and that there should be a simpler way. Well now there is, you can just drag it to a different tab!
Additionally to this you can also drag tabs around, rather than relying on the numerical index.
Simple improvements to save bundles of time :).

No more popups

A lot of the workflow in Umbraco is done through the use of popup windows, things such as creating, moving and managing permissions of a document. With the change into MVC we were able to revisit this idea, and from that we've decided that when possible we'll just use the main editor pane rather than a popup. This gives a lot more visible space to provide users information during the process of creating a new node, or moving one around the CMS.
 

Media is content

In Umbraco 4 there is a reasonable distinction between the idea of media and content, although they share a lot of the same root concepts. Thanks to the changes in the way data is treated (aka the Hive) we've been able to bring these concepts even closer, making the API for working with media identical to working with content. It also means that customizing the media types should be exactly the same as document types.

Localization improvements

We're not language gurus, we're CMS gurus, but thanks to the awesome work of Niels Kurnel localization is going to be even more powerful in Umbraco 5 than ever before. There's more to it than can be summed up in a paragraph so I recommend you go check out Niels' CodeGarden presentation on the new localization features of Umbraco 5. It's also available for you to use separately from Umbraco, but more on that in a future post!

Sprite framework

Umbraco 5 will make it easier to use CSS sprites for DocType icons, etc. This works by looking for a CSS file with the same name as the sprite image file. Umbraco will then parse the CSS file and find all the CSS sprite rules to produce a list of images which are all located within the sprite itself.
This makes it easier to utilize sprites within the Umbraco back office for content editors to work with.
 
That wraps up the first in this series about Umbraco 5 gems, and our look at what's going to be awesome for Content Editors. Stay tuned for more Umbraco 5 gems!

Every year at CodeGarden we run a package competition, where attendees have the opportunity to submit an Umbraco package that extends the out of the box functionality of Umbraco.

At the end of CodeGarden we ask all our package competition entries to present their package, giving them 5 minutes a piece to present before being thrown off the stage, finished or not. Submissions can range from useful and powerful packages to the downright silly, which of course, we love :)

Prizes

This year we introduced a theme for our package competition prizes, deciding on cool DIY build projects (such as some great Arduino projects that we found).

Third Prize - Useless Machine
This is not an Arduino project, however we saw this and it made us smile.
http://www.youtube.com/watch?v=Z86V_ICUCD4

Second Prize -Thingamagoop 2
This is a handmade, analog and digital synthesizer that you control with light.  It is built with Arduino so it could be reprogrammed to do something else.
http://bleeplabs.com/thingamagoop2/

First Prize - Thing-O-Matic MakerBot
This was a great first prize, an open source Arduino 3D printer from the guys over at MakerBot in New York that allows you to print 3D objects from your computer. Want to print out a kazoo to relive the memory of the CodeGarden marching band from bingo, sure can!!
http://www.makerbot.com

The Winners

The packages were judged by the attendees with the biggest cheers and the winners for this year were as follows:

3rd Place - uBackChat
Lee Kelleher demo'd a package that allowed users of the Umbraco back office to instant message one another, this could be useful for clients where more than one editor is likely to be working on the site at the same time.

http://our.umbraco.org/projects/backoffice-extensions/ubackchat
https://bitbucket.org/vertino/ubackchat/src

2nd Place - Optimize It
Morten Christensen demo'd a great utility package for Umbraco that allows you to optimise your CSS and JavaScript from the Umbraco back office in a few clicks, such as generating a sprite image from your CSS, prettify and minify your CSS and other useful utilities that you may want.
Unfortunately Morten ran out of time when demoing this at CodeGarden, however he still managed to bag 2nd place with this fantastic package.

http://our.umbraco.org/projects/backoffice-extensions/optimize-it
http://blog.sitereactor.dk/2011/06/19/optimize-it-package-for-umbraco

1st Place - uBrokeIt
Tim Payne showed us a great package called uBrokeIt, which was a great little fun package that was not to be taken seriously. uBrokeIt allows you to introduce non destructive and amusing bugs into the back office such as 'boss mode' and 'kitten mode'. Rather than me trying to explain this fun/silly package, I will let Tim do a much better job with his screencast.

http://our.umbraco.org/projects/backoffice-extensions/ubrokeit
http://www.screenr.com/22Bs

However with these great packages I need to give a big honourable mention to Matt Brailsford who was the only one to submit a package developed against V5 of Umbraco, so massive kudos to Matt for demoing a V5 package. High Five You Rock!

Congratulations to all our winners and thanks again to everyone who entered the package competition. High Five You Rock! I must admit I am jealous of Tim winning that awesome 3D printer, it looks like it will be a fun project to build!

Has all this talk of CodeGarden got you excited about what next year's CodeGarden will bring? Wondering how can it get any better? Trust us, it can! So make sure to get in early with our super early discount for CodeGarden12 tickets at a low price for a limited time (first 100 tickets or when we remember to turn the discount off).

Well that's it for this year's CodeGarden follow-up blog posts, make sure you keep your eyes peeled on the Umbraco twitter stream and the CodeGarden11 site as we continue to release a new video each workday.

Until next year.... have fun, and don't forget to pack your kazoo's for next year :)

Cheers,
Warren & The Umbraco HQ

Only two weeks remain before we return to Sydney Australia to run the next round of Umbraco certification courses from the 19th to the 22nd of July.

If your company uses Umbraco as its main CMS platform, I would encourage you to consider certifying your developers and becoming a Certified Partner.  Certification not only helps affirm and build on your developer's knowledge but also provides credibility for your company when pitching for work.  To become a Certified Partner involves having four certifications at either Level 1 or 2.  This can also be obtained by having two developers certified at both level 1 & 2.  Currently in Australia we provide a package rate for developers who choose to do both levels in the same week and this can be a very cost effective option for gaining Certified Partner status. There are currently only two spots left on level 1 which also means there are only 2 package deals available.  This is a great opportunity for a company to take the next step in professionalising their use of Umbraco.  Do not hesitate, register today [external site].

From a trainer's perspective, I really enjoy teaching the courses as it's great to see the "AHA!" moments when a developer discovers something new, and then seeing the satisfaction a developer gets when they finish up the course and can finally claim the badge of Umbraco Certified Developer.  You'd be surprised how many developers come purely to 'gain the certification' assuming they know most of what there is to know, who walk away going 'Wow, I learnt so much!' But what I enjoy the most is when I see that developer become part of the wider developer community, contributing on the forum, twitter and in some cases developing packages.

Umbraco is so much more than just a great tool that you use to build content managed websites. It is also a community of dedicated developers passionate about what they do. I encourage all newly certified developers to join in the conversation and contribute back as there are many opportunities to give input even if you are not a "Core" developer.

This round we have a change of venue and have moved to a more central location in the city at the offices of Umbraco Gold Partner Next Digital. Massive thanks to Next Digital for providing the venue, we really appreciate the support and help with logistics.  If you are interested in training or certifying your team (or yourself) but can't make it to this round, we will be running another set of courses in Australia before the end of the year.  Please contact me for more details.

And last, but not least, as we place a lot of value on community here at Umbraco, we will be running a meetup whilst in Sydney for all Umbraco users, whether you are attending the training or not.  If you'd like to come along let us know by signing up on our.umbraco.org, we'd love to see you there.

Peter Gregory - Umbraco HQ Australia

This year at the Umbraco HQ we decided to bring back the Umbraco awards for two reasons. First was to celebrate all the awesome and high quality work that the community produces when  building great Umbraco websites, and secondly it was a great way for us to collect new & exciting case studies for Umbraco's own website.  So expect to see these featured on the site very soon!  We short listed three finalists for each category.  The winners were announced at the end of CodeGarden where each winner was presented with a very unique award: a custom painted 18inch Umbraco branded Mega Munny. Below, Per Ploug from HQ talks us through the category winners.

Best Technical Solution

Home.dk
Kraftvaerk - www.nytcms.dk

HollandToer.nl
WVD Media - www.wvdmedia.nl

FDIH.dk
CodeHouse - www.codehouse.dk

Winner: Home.dk
"Home.dk was selected because it scales really well, (one of the biggest sites in dk) and because of their efforts to make the editing environment extra friendly. Editors can put together microsites by just picking content with various pickers, so no more need for IT because non-tech people can just put together the sites themselves."

Read how happy the Kraftvaerk team were to win the Umbraco Award on their blog
http://www.nytcms.dk/nyheder/kraftvaerk-vinder-umbraco-award

Best Designed Site

LoveBeverlyHills.com
RTP Interactive - www.rtp.com

HenningLarsen.com
1508 - www.1508.dk

NLEngenharia.com
Massive Visuals Agency - www.itsmassive.com

Winner: HenningLarsen.com
"Henning Larsen was chosen for its functional design.  You can pick cases, articles etc and generate a PDF from the site, which is cool for their users, but their sales people actually also use it to make ultra-fast sales pitches, and it's a beautiful site."

Best Integration

HenriLloyd.com
Amaze - www.amaze.com

TescoPLC.com
MerchantCantos - www.merchantcantos.com

ThisIsCentralStation.com
ScreenMedia - www.screenmedia.co.uk

Winner: ThisIsCentralStation.com
"This is Central Station was selected as best integration because it's integrating a social network with Umbraco, it's a nice integration, and its design and UX is actually different from all the Facebook clones out there. So great use of third party system + the flexibility of Umbraco in regards to design."

Read how attached Jon has become to the Mega Munny/Umbraco Award ScreenMedia won
http://www.screenmedia.co.uk/blog/2011/june/we-won,-we-won-the-umbraco-award-2011

It was really hard for the panel to choose the nominees & winners from all the great entries we received. So if you entered into the Umbraco Awards, we would like to say a BIG thank you. The other reason we started up the Umbraco awards again this year, was to get great case studies for us to use.  We have previously asked the community before but without much success, now we have a ton of great case studies to showcase. So expect to see them on the Umbraco.com site soon.

Thanks again for all the great submissions. In the final CodeGarden11 follow up blog post I will blog all about the package competition that we hold each year at the end of the conference.

Until next time....
Warren & The Umbraco HQ