NDC Magazine by NDC- The Developer

NO 2/2014

MAGAZINE

F O R S O F T WA R E D E V E L O P E R S AND LEADERS

FLUENT API’S KEVIN DOCKX Add new dimensions to your algorithms using

5 AUDIO TRICKS

you didn't know browsers could do

F# TYPE INFERENCE

JORY PRUM

VAGIF ABILOV

NORWEGIAN DEVELOPERS CONFERENCE

ACCELERATING WINDOWS STORE APP DEVELOPMENT

Oslo Spektrum, 4-6 June Pre-workshops, 2-3 June

DAVID BRITCH

CREATING YOUR OWN SKUNK WORKS NIALL MERRIGAN

NDC MAGAZINE

Contents

2-2014

From Crisis to Success The worlds first software engineering conference was h e l d 4 6 ye a r s a g o i n Garmisch, Germany. At this conference the term "software crisis" was first used. Software projects were running over-budget and overtime, and in general did not meet expectations on quality and functionality. That conference represents a turning point in our history. We wanted to run larger software projects, but their failing seemed unavoidable. This started the search for ways to manage projects, smarter ways to structure code, better ways to do programming. Our outlook is better now, but our technology and expectations keep changing, and the problem identified in 1968 will never completely be solved. Every time we start a new software project we take on the risk of failure. This is why conferences like NDC is so important. At NDC we bring together diverse experience from software projects using many different methodologies and technologies. Smart people get to present their view of what's working, and the community get to react and respond. As a developer you get to review years of experience in the course of just a few days - stuff you can take home to improve your own chance of implementing successful software projects.

SP PR ECIA OGR L AM FUNC MIN TI G ISONA SU L E

MAGAZINE

FUNCTIONAL REACTIVE PROGRAMMING

F O R S O F T WA R E D E V E L O P E R S AND LEADERS

MIKAEL BREVIK AND STIAN MØLLERSEN

THE POWER OF PARTIAL APPLICATION

CREATING RESPONSIVE UIS WITH F#

SCOTT WLASCHIN

RACHEL REESE

ARTICLES 5 Audio Tricks ...................................................................................................... p. 4 Creating your own Skunk Works

NDC 2014 will cover many different and vital topics. One I find especially important is functional programming. The industry is finally admitting the value of FP, and this year you will have the opportunity to dig deep into two FPtechnologies: The first is F#, which has grown up and gives us a very powerful functional language on the .NET platform. The second is Erlang, which has proven its unique strengths in projects like CouchDB, RabbitMQ, WhatsApp, and Facebook's chat.

.................................................

p. 8

SonarQube as an Educational Platform ........................ p. 12 Modern Web Front-End Architecture .............................. p. 18 Accelerating Windows Store app development using Prism for the Windows Runtime ............................ p. 22 Let’s get physical

........................................................................................

p. 26

FsCheck: smarter validation with Property-based testing

....................................................................

A Few Words on Fluent API’s

.......................................................

p. 30 p. 34

There are other areas where we see a lot of change, like JavaScript. And NDC will bring you a lot of content and opinions about how to run successful JavaScript-based projects. There will be many talks related to DevOps, and emerging topics like "the Internet of things" are also covered.

The technical depth and breadth of

However, the most important criteria for success in software engineering is not the technology. It's the people! Software is usually a team effort. That is why NDC also focus on how we communicate, how we collaborate, and how we motivate. I hope NDC 2014 will motivate you to improve your skills, and make it more likely that your projects become a success!

and Delegated API Access .............................................................. p. 50

Best regards,

Entertainment and food

an Architect ........................................................................................................ p. 40 Add new dimensions to your algorithms using F# type inference Code Club for Juniors

..................................................................

p. 42

............................................................................

p. 48

OpenID Connect: Unifying Authentication

COURSES Course overview

..........................................................................................

p. 54

NDC 2014 The NDC Agenda Committee ...................................................... p. 58 ....................................................................

p. 62

Oslo - the capital of Norway ......................................................... p. 66

Torbjørn Marø aboutme.kjempekjekt.com

Meet the user groups at NDC community

..................

p. 70

Pre-conference workshops ........................................................... p. 74 Program Wednesday - Friday ....................................................... p. 76

Advertise in the NDC Magazine

Editor: Kjersti Sandberg

and meet your target group!

Marketing Manager: Charlotte Lyng

Workshops Page 70

COURSES See descriptions Page 56

TEACHING DEVELOPERS NEW TRICKS

Member of Den Norske Fagpresses Forening

For more information about advertisement, please contact Charlotte Lyng at +47 93 41 03 57 or charlotte@programutvikling.no

KAROLINE KLEVER

THE DEVELOPER REBRANDED AS NDC MAGAZINE

IC ECOLAB

67 2

Print run: 11,000 Print: Merkur Trykk AS

24 1

Publisher: Norwegian Developers Conference AS. By Programutvikling AS. Organisation no.: 996 162 060 Address: Martin Linges vei 17-25, 1367 Snarøya, Norway. Phone: +47 67 10 65 65. E-mail: info@programutvikling.no

Design: Ole H. Størksen Uncredited images are from Shutterstock, except portraits. © Kristoffer Sunnset

NO 1/2014

int in

g compa

ÂŠ Avesun /Shutterstock

I began in web development way back in February 1995. That's long enough to remember the days when web pages could only be grey, links were blue or purple, pictures as links always had a border around them, and there was no video or audio on a page. Oh, and all code had to be hand-written... from scratch! By Jory K. Prum

A lot has changed since the days of NCSA Mosaic. Color, good design, separating style from structure, and applications have come to the web over the past two decades. Developers have seen the era of plugins come and go, bringing with them the ability to animate, to provide rich experiences with modern typography, and leaving us enriched with radically improved user experiences. Only two years ago, however, one major aspect was almost completely left behind: audio. Sure, HTML5 brought with it the <audio> element for playback and some control over how playback worked and looked. But too many aspects of <audio> were left up to browsers to determine. For example, iOS will only play a single <audio> channel at a time and will not play any sound until the user taps on something, making it impossible to use <audio> to create user interface or other sound effects for applications and games.

5 Audio Tricks You Didn't Know Browsers Could Do 4

Fortunately, the Web Audio API began to gain momentum in mid-2012 and is now supported in most browsers today. Web Audio API gives developers considerable capabilities with playback, manipulation, and even synthesis of sound. With support in Chrome, Safari 6+, iOS 6 and newer, Firefox, Opera, Chrome for Android, and more, Web Audio API is here to stay and provides powerful abilities most developers aren't aware of yet. So without further delay, here are five audio abilities you probably didn't know your browser could do!

1. VISUALIZING AUDIO Audio is a mystery to most people. It's something that just happens around them without their awareness; they only know of its existence if something is out of place. One way people become more aware of sound is if it is translated into something visual. One of iTunes' most popular features has always been the visualizer, and there's nothing more useful to an audio professional than audio meters and spectral analysis. Using the Web Audio API, it is possibile to create all kinds of interesting visualizations of sound, from an oscilloscope representation to complex spectral drawings, all in realtime! Two outstanding examples of audio visualization are provided by Stuart Memo and Jos Dirksen. Memo has a library called Wavy Jones that uses <canvas> to create an oscilloscope and is incredibly simple to include in a project. [ https://github.com/stuartmemo/ wavy-jones ] Dirksen's example goes much further, providing multiple styles of visualization, including realtime peak meters, multi-frequency meters, and spectral graphing. [ http://www.smartjava.org/content/exploring-html5-webaudio-visualizing-sound ]

The question I often get about surround features relates to end users, though. How will users get to hear your surround stream? Fortunately, this is quite simple: connect your computer to your home theatre system using HDMI and everything should work automatically! Voila: surround on the web! 3. SYNTHESIS You might have seen Google's very popular Moog synthesizer doodle [ http://www.google.com/doodles/robertmoogs-78th-birthday ] back in May 2012. It was the first use of the Web Audio API on a large scale, working in the Chrome browser and falling back to Flash for all others. Today, there are tons of great synthesizer examples. Some even include interoperability between them and there's even initial support for the upcoming Web MIDI API, allowing hardware controllers to be utilized. One of the best ways to get your hands dirty in this realm is by jumping into Stuart Memo's very nice example. [ https://github.com/stuartmemo/sympathetic-synth ] What Memo has put together is a very straightforward implementation of how to make a synthesizer with various controls. It even makes use of his Qwerty-Hancock keyboard controller to let you play the synth using your computer keyboard!

4. MICROPHONE INPUT One of the most interesting abilities that's arrived with the Web Audio API and getUserMedia is the ability to capture audio input from the user via their device's built-in microphone. Not only can sound be captured, it's possible to save that audio data as a WAV audio file to the user's hard drive! It's definitely worth checking out Thibault Imbert's fantastic example, which walks through how each portion of the code works. [ http://typedarray.org/from-microphone-to-wavwith-getusermedia-and-web-audio/ ] 5. EVENT-DRIVEN PLAYBACK Probably the most useful single thing the Web Audio API can do is enable developers to play sounds when other events occur, such as firing a weapon in a game, clicking on a button, or a fading between ambience sounds or music as a page is scrolled. Being able to call individual sound events wasn't impossible with the <audio> element, but as mentioned before, the limitations were drastic and based on which platform the users was using. But with the Web Audio API, it's quite easy to setup events and simply fire them off as needed. I've assembled several examples of how this can be implemented. [ https://github.com/html5audio/ interactive-audio ]

Jory K. Prum is principal engineer and owner of studio.jory.org, a game audio production facility located in San Francisco, California. With 20 years of audio production experience, Jory has focused primarily on video game sound since 1999 and has been responsible for sound, voice, and music in many award-winning games, such as "The Walking Dead".

There is so much more you can do with the new Web Audio API, and getting your hands dirty is quite easy and painless. Please check out the http://html5audio.org for more examples and inspiration!

ÂŠ scyther5/Shutterstock

2. SURROUND PLAYBACK Did you know you can play 5.1 audio from a browser? Not many do! Chrome for Desktop has supported this for a while, both in the <audio> element and using Web Audio API. Radio France even broadcasts many programs in surround and binaural streams! [ http://nouvoson.radiofrance.fr/paysagesonore/am-i-berlin?format=5.1 ] Implementing surround

audio output is surprisingly easy and I have a working example with code available for you to try out that plays back a 5.1 Ogg Vorbis file. [ http://www.html5audio.org/2013/03/ surround-audio-comes-to-the-web.html ]

Creating your own Skunk Works using the Cloud By Niall Merrigan

Back in the early 50s, the Lockheed Company had a super secretive R&D division called Advanced Development Projects, although it was more commonly known by its then unofficial alias “The Skunk Works”. Founded by the legendary inventor and aircraft designer Kelly Johnson, it was the place where magic happened and the weird and wonderful were normal every day occurrences. 8

Unhampered by bureaucracy and cloaked in secrecy, The Skunk Works created amongst other things the designs for the SR-71 Blackbird, the F-117 Nighthawk and the F-22 Raptor. In many cases, development of a project started months before an official contract was even received. Most of the work performed there was rapid prototyping and design.

The Have Blue project in 1976, which turned out to the prototype for the F-117 Nighthawk stealth fighter, was completed in just 18 months, which is remarkable considerable how far from a traditional aircraft the stealth fighter is. So what does this have to with development? The name Skunk Works

in business and engineering terms means any place where you conduct R&D projects that are hidden from general view and where, well anything goes. It can also mean development projects that are not officially recognised or supported by management or in some cases are done in a way that is outside the normal working environment. It is where a developer plays

with when they have a bit of down time or have a flash of inspiration for something. Nearly every developer has an off the books project that they tinker with. A project where they try out new technologies and ideas. It could be something as simple as a proof of concept for an application that they are working on in their real world job or something that they have seen that they would like to play with. My own downtime project is the Swiss cheese website which is a sample web application with security holes built in to show developers how easy these mistakes are to make and how to look for them in their own code. To build this site I need a copy of different server systems to test it on. Now some of us, yours truly included have gotten around this need for additional machinery by having an under the desk server, some old machine often acquired by not delivering a retired device back and hoping that IT will forget about it. Unfortunately, these semi servers often cannot handle the demands of the new operating systems and can be painfully slow to work with, stifling the creative juice that are needed for these types of projects.

There is where the cloud comes in. You can spin up a VM in the cloud, running the latest and greatest bits, a VM which you fully control and that you can remote in from anywhere in the world and develop to your heart’s content. If you do not need a VM, you can run your web application in the cloud. If your proof of concept code suddenly becomes a production ready system, you can quickly and effortless scale out to production quality in a couple of minutes. All this for a low price. Many cloud providers offer either free or pay as you go subscriptions. In the Microsoft world, Microsoft Azure (recently rebranded from Windows Azure) offers free trials and pay as you go. For those of you with MSDN subscriptions, Microsoft offers a certain amount of credits every month on its Azure platform for you to try out the full range of services. Amazon offers on its AWS platform the free usage tier. So go create your own Skunk Works in the cloud, a place where you can create wonderful and magical applications without the overhead of having to buy new computers.

Niall is the Head of Custom Software Development in Capgemini Stavanger,He is also a Microsoft ASP.NET MVP, and general rugby nut (which means he shouts a lot). He has a passion for web technologies, security and whiskey which can lead to some interesting discussions. He can be found on twitter as @nmerrigan and hosts a blog at http:// www.certsandprogs.com

DEN MENNESKELIGE FAKTOREN.

Hvorfor er vi 1000 dedikerte IT-eksperter på Dustin? Kanskje fordi vi har et av Nordens største sortimenter av IT-produkter og IT-tjenester. Og når det finnes så mye å velge mellom er det bra å ha noen å snakke med. Hvordan kan vi hjelpe deg å finne rett?

BESTILL DIREKTE PÅ DUSTIN.NO ELLER RING 21 04 40 40 SÅ HJELPER VI DEG. 10

SonarQube as an Educational Platform

I've been using SonarQube[1] platform for more than four years. I remember the time when it was making its first baby steps as a code quality management tool. It looked more like a system that was integrated with various thirdparty static analysis tools (like PMD, FindBugs etc.) and provided a few but important code quality metrics. By Patroklos Papapetrou

Many things changed over the next years. SonarQube today is considered a mature software eco-system (in my humble opninion the best) that provides a set of features for successfully applying the process of continous inspection to any development methodology.

In this article I'm not going to discuss about SonarQube's star features that help you manage and control your Techinical Debt. I will give a different point of view and explain how you can use it as an educational platform.

TEACHING DEVELOPERS WITH CODING RULES Since release 4.0, integration of external tools has been gradually dropped off and several of the coding rules provided by these tools have been replaced by rules, written using an in-house developed (but still open-sourced) language parsing library which is called SonarSource2 Language Recognizer (SSLR)3. One of the great benefits of this rule re-writing is that they include a very explanatory description about the purpose of the rule as well as several code examples – if applicable – that present the right and wrong way of writing code.

Let's take a look at the following image which is a snapshot of a java coding rule that checks if Object. equals is overridden when Object. compareTo is overridden. As you see, the rule is not only backed-up by a very detailed and well-argued explanation but it also contains two code snippets: a compliant and a not-compliant one.

Developers are able to read all this information when they are looking at an issue4 that violated this rule. They are supposed to understand what they did wrong, fix it and hopefully don't make the same mistake again in the future. But hey!! You don't have to sit down and wait for SonarQube to raise an issue so that developers read

about the correct way of writing code. You can send the developers to study the rules anytime they want. In other words, educate them before a quality flaw appears. In the company I work with, we have filtered out the rules that are not aligned with our coding style and then we grouped them by using the tagging mechanism provided by SonarQube5. Then, we organized training sessions where we walked through every rule of a specific tag(group) and we discussed the details of each rule and the suggested way of coding. That's all! We noticed that the developers started writing better code from the very next day and SonarQube's issues were very limited for the coding rules we have already discussed. LEARNING FROM CODE REVIEWS If you don't have enough time to allocate for the previous suggestion then you might consider an alternative

Core Spring 24. June, 16. September and 04 November in Oslo With Mårten Haglind In this four–day bootcamp you learn how to use the Spring Framework to create well–designed, testable business applications in an agile manner. Students build a Spring–powered JEE application that demonstrates the Spring Framework and other Spring technologies in an intensely productive, hands–on setting.and its functional capabilities.

approach. Most of you, are probably familiar with code reviews or at least know the basics and the benefits of applying such a practice. SonarQube provides a built-in tool that facilitates the code review process.

you review all SonarQube issues and prioritize them. As soon as you finish and plan the required issues , let's say for the current iteration, you can ask the developers to work as a team and come to a solution, especially

In a few words, each issue can be assigned to a developer and can be also planned in an action plan. Code reviewers are able to confirm the issue, can mark it as a false-positive case by providing some additional reasoning for that, or just comment on it with some suggestions or possible solutions to fix the problematic code.

for those issues that an one-line fix is not enough. Finally document the solution by commenting the relevant issues so that everyone can see it. The benefit of this approach is that developers are required to understand the underlying broken coding rules for all issues (not only for the ones that they created) and then figure out the fix.

All this issue-interactivity can be viewed as a way to teach people, especially young developers. Like the previous section, you can ask developers to read comments or study the raised issues. A nice way of doing this, without needing to cut time from your development tasks, would be the following. First prioritize SonarQube issues and plan them using action plans. For instance, you might have an action plan that includes all issues that should be fixed during the current iteration and another one for future iterations. Then try to hold short meetings during the iteration where

CONCLUSION Educating developers should be constant and continuous. But this is something that most companies forget, intentionally (lack of budget) or not (lack of time). If we try not to regard it as a necessary evil, but something that can take place during every day development tasks, then we might have a better chance. SonarQube's coding rules and the easy-touse coding review mechanism come to the rescue and can be put-upon to teach developers how to write better code and eventually make them better professionals.

REFERENCES 1 http://www.sonarqube.org 2 http://www.sonarsource.com 3 http://docs.codehaus.org/display/ SONAR/SSLR 4 http://docs.codehaus.org/display/ SONAR/Issues 5 http://docs.codehaus.org/display/ SONAR/Configuring+Rules#ConfiguringRules-TaggingRules

Patroklos Papapetrou is a Java architect, addicted to software quality and an agile team leader with more than 15 years of experience in software development. He believes and invests in people and team spirit seeking quality excellence. He’s co-authoring “SonarQube in action” book, he is an active SonarQube community member and plugin contributor. He treats software systems as ﬂowers that’s why he prefers calling himself a software gardener.

Java 8 19. November in Oslo with Venkat Subramaniam With the introduction of lambda expressions and method references in Java 8, we can now make use of functional style of programming. This course is designed, by author of the first book on Java 8 to hit the market, to help you make a quick and effective transition to Java 8 and its functional capabilities.

For complete course descriptions, time and place, visit www.programutvikling.no

Get all access to a whole week of inspiration or mix and match as you like

ndcoslo.com

Ticket types

Price

All Access Pass (Workshops + Conference) 3 Day Conference Pass 2 Day Conference Pass 1 Day Conference Pass

NOK 18500 NOK 11500 NOK 10000 NOK 8500

2 Day Pre-Conference Workshop Pass 1 Day Pre-Conference Workshop Pass

NOK 9800 NOK 6800

2 Day Pre-Conf. Workshop + 1 Day Conf. Pass 2 Day Pre-Conf. Workshop + 2 Day Conf. Pass

NOK 13000 NOK 16000

Pre-Conference Workshops 2-3 June

25% VAT will be added to all ticket types.

Inspiring SINCE 2008 Developers We are proud to present the seventh NDC. Thanks to our inspiring partners who make it happen!

For information about partnership deals, please contact: charlotte@programutvikling.no tel.: +47 93 41 03 57

Become a partner today!

@NDC_conferences #ndcoslo

ndcoslo.com

Overview of Modern Web Front-End Architecture

In the last few years, web development has shifted from working mostly in the backend for rendering and operations toward front-end development. Today, most of the web apps that we are building will have a rich front-end that is implemented by proven design patterns like modules and MVW. This article will explain some of the modern web app architecture building blocks. By Gil Fink

MODULAR JAVASCRIPT The starting point in building a maintainable front-end is to modularize your JavaScript code. Modules help to separate the concerns in the app you build. As a side effect of JavaScript modules creation, your code will be more testable and more reusable and of course smaller. You can create modules using native JavaScript patterns such as module and the revealing module patterns. Another option to create modules is using a library such as RequireJS or Almond. ECMAScript 6, the next version of JavaScript, will include a module keyword and will enable the creation of modules easily. Up until that is going to happen, you should use JavaScript patterns. THE MODULE PATTERN The module pattern is very straight forward. It uses the fact that JavaScript has function scopes to encapsulate the internals of the module. Lisiting 1 shows a code snippet for the module pattern structure. Listing 1 – Module Pattern Structure var Module = function () { // private members // private functions

}

return { // public members };

As you can see in Listing 1, each module has private members and functions and you return a JavaScript literal object which is the façade to the module internals. You can create a lot of module instances from the module template that you’ve created. Listing 2 shows a code snippet of a more specific example that uses the module pattern:

Listing 2 – Creating a Car Module Using the Module Pattern var Car = function (elmId) { // private members var elm = document.getElementById(elmId), speed = 0; return { // public members drive: function (newSpeed) { speed = newSpeed;

}

};

}

elm.innerHTML = 'current speed: ' + speed;

// later in code var car = new Car('carElement'); car.drive(100);

In the Listing 2 you can see that we are creating a module called Car. The Car module includes two private members – elm and speed. The module itself exposes a function called drive that is used to change the speed of the car and to write to a HTML element the current speed. THE REVEALING MODULE PATTERN The revealing module pattern resembles the module pattern but with a small change. In the revealing module pattern you use an immediate function execution expression (IFEE) to create only one module instance. Listing 3 shows a code snippet of the revealing module pattern structure. Listing 3 – Revealing Module Pattern Structure var module = function () { // private members // private functions return { // public members };

}();

As you can see from Listing 3, you run the module creation code inside an IFEE and that will create a singleton module. Listing 4 is an example of how to use the revealing module pattern with a car module.

Figure 1 shows the MVC parts and how they communicate with each other:

Listing 4 – Using Revealing Module Pattern to Create a Car Module var car = function (elmId) { // private members and functions var elm = document.getElementById(elmId), speed = 0, doDrive = function (newSpeed) { speed = newSpeed; elm.innerHTML = 'current speed: ' + speed; }; return { // public members drive: doDrive }; }('elmId'); // later in the code car.drive(100);

In the code, you can see that the car module includes two private variables, elm and speed, and one private function, doDrive. Later on, you return the façade for the module that might not look like the inner implementation (doDrive is exposed as drive). There are more module patterns that you can use such as prototype pattern or revealing prototype pattern. You can use these patterns to create JavaScript modules or you can use a library such as RequireJS or Almond to manage and create modules. MVW In most of the web apps that you are going to build, you will probably use some sort of MVW framework such as AngularJS or Ember. The MVW acronym stands for Model/View/ Whatever where most of the framework/libraries use the model and view and add more components. MVW frameworks are mainly based on MVC and MVVM patterns. The frameworks help us to separate the app concerns in the front-end and help to structure your JavaScript code.

MODERN WEB APP ARCHITECTURE When building web apps, you will combine both modular JavaScript and a MVW framework. In Figure 3 you can see how MVW framework is used in the front-end as a tool to separate concerns:

In Figure 4 you can see how the logical modules are separated. Each module has its own implementation and the way modules communicate is through a mediator/event aggregator. The application core exposes the core libraries like jQuery or Backbone.js through the façade to each module. Using this separation will help you to manage your code and your modules easier. SUMMARY Modern web applications use JavaScript heavily. In order to create a more robust solution, you will have to use modules and MVW framework as part of your architecture. Building a web application is not an easy task but with today’s tools and patterns it is becoming easier. Note: Some of the content in this article was taken from Pro Single Page Application Development book.

Figure 1. MVC Pattern

MVC helps to separate different concerns like handling inputs, UI and data. AngularJS uses the MVC pattern in its architecture. MVVM MVVM is another known UI pattern. The acronym stands for Model/View/ViewModel. Each of the MVVM parts has its own purpose: 1. The model represents the application core and mostly is used as data structure. 2. The view is the display of the model. 3. The ViewModel handles UI input and is responsible for one/two way binding between the view and the model. The difference between MVC and MVVM is the ViewModel responsibility. While controllers can serve more than one view, the ViewModel is bounded only to one view. Moreover, the ViewModel is used as a container for data and commands that the view can use and not as an orchestrator like controllers in MVC. Figure 2 shows the MVVM parts:

Figure 3. Modern Web Architecture

Note: The diagram includes also a backend implemented by ASP.NET which is non-relevant to the discussion in the article. In the browser area what you see is how a logical module in the app will look like in modern web architecture. The module has view/s, controller/ViewModel, and model and if needed a data service to interact with the server. Each module interacts with the application core that is built upon core JavaScript libraries such as jQuery and AngularJS. App architecture is constructed with a lot of modules, application core and a mediator/event aggregator, which decouples the modules from each other. Figure 4 shows a high level diagram of a front-end architecture from another aspect.

Gil Fink is a web development expert and Micrsoft ASP.Net MVP. He is currently consulting for various companies, where he helps to develop Web solutions. He is also co-author of several Microsoft Official Courses (MOCs) and training kits, co-author of "Pro Single Page Application Development" book (Apress) and the founder of Front-End.IL Meetup.

MVC MVC is one of the famous UI patterns which is wide spread in web development. The acronym stands for Model/View/ Controller. Each of the MVC parts has its own purpose: 1. The model represents the application core and mostly is used as a data structure. 2. The view is the display of the model. 3. The controller handles input and is responsible to pass the model to the view.

Figure 2 – MVVM Pattern

MVVM helps to separate different concerns like handling inputs, UI and data. KnockoutJS is an example of a JavaScript library that implements the MVVM pattern.

Figure 4. Modern Web Architecture from the Point of Modules

Accelerating Windows Store app development using Prism for the Windows Runtime Many of you will be familiar with Prism, a patterns & practices1 release that helps you to design and build composite applications. In May 2013 the patterns & practices team released a new guide for Windows 8 about creating Windows Store apps using C# and XAML. The guide came with source code for Prism for the Windows Runtime, source code for the AdventureWorks Shopper product catalog and shopping cart reference implementation, and documentation. By David Britch

The documentation provided guidance on how to implement MVVM with navigation and app lifecycle management, validation, manage application data, implement controls, accessible and localizable pages, touch, search, tiles, and tile notifications. It also provided guidance on testing an app and tuning its performance.

The logical architecture of a typical Windows Store app that uses Prism is shown in the following diagram.

In January 2014 the guide was updated for Windows 8.1 and Visual Studio 2013 and can be found on the Windows Developer Center2. WHAT IS PRISM FOR THE WINDOWS RUNTIME? Developers of Windows Store business apps face several challenges. App requirements can change over time. New business opportunities and challenges may present themselves. Ongoing customer feedback during development may significantly affect the requirements of the app. Therefore it's important to build an app that it is flexible and can be easily modified or extended over time. Prism for the Windows Runtime provides an architecture that helps to do just that. It is designed to help developers create apps that need to accomplish the following: • Address the common Windows Store app development scenarios.

• Separate the concerns of presentation, presentation logic, and model through support for Model-View-ViewModel (MVVM). • Use an architectural infrastructure to produce a consistent and high quality app.

This architecture helps to produce flexible, maintainable, and testable apps. It includes components that help to accelerate development of your app by providing support for MVVM, loosely coupled communication, and the core services required in Windows Store apps, allowing you to focus on developing the user experiences for your app. For more info see Getting started using Prism for the Windows Runtime3, and Using Prism to create a Windows Store app4.

HOW DOES PRISM FOR THE WINDOWS RUNTIME SHIP? Prism for the Windows Runtime ships as two libraries that help developers create managed Windows Store apps: â&#x20AC;˘ The Microsoft.Practices.Prism.StoreApps 5 library provides support for bootstrapping MVVM apps, state management, validation of user input, navigation, data binding, commands, and settings. â&#x20AC;˘ The Microsoft.Practices.Prism.PubSubEvents6 Portable Class Library allows communication between loosely coupled components in an app, thus helping to reduce dependencies between assemblies in a Visual Studio solution. In addition, the libraries are also available as NuGet packages, and their source code can be downloaded as part of the AdventureWorks Shopper7 product catalog and shopping cart reference implementation. USING PRISM FOR THE WINDOWS RUNTIME In order to demonstrate using Prism for the Windows Runtime, I've written a sample photo viewing app, which can be downloaded here8. In the app, there are two pages. The first page presents a thumbnail gallery view of photos in the users Pictures library. Clicking on a thumbnail takes the user to the second page which displays the full image and allows it to be converted to greyscale. In the app, support for MVVM, navigation, and state management are all provided by Prism for the Windows Runtime. The first step in using Prism for the Windows Runtime is to add a reference to the Microsoft.Practices.Prism.StoreApps5 library to your project, in order to use the services provided by the library. The MvvmAppBase class provides core startup behaviour for an MVVM app, with its constructor being the entry point for the app. Your App class should then derive from the MvvmAppBase class, and add app specific startup behaviour such as the page to navigate to when the app starts. There are two view classes in the app, MainPage and PhotoPage, that bind to the MainPageViewModel and PhotoPageViewModel classes respectively. Each view class derives from the VisualStateAwarePage class, provided by the Prism. StoreApps library, that provides view management and navigation support. Each view model class derives from the ViewModel class, provided by the Prism.StoreApps library, that provides support for property change notification, navigation, and suspend/resume functionality. A static ViewModelLocator object, provided by the Prism. StoreApps library, is used to manage the instantiation of view models and their association to views. A required override in the App class is the OnLaunchApplication method, from where you will typically perform your initial navigation to a launch page. C#

This method uses the NavigationService, provided by the Prism.StoreApps library, to navigate to the MainPage in the app when it launches. "Main" is specified as the logical name of the view that will be navigated to. The default convention specified in the MvvmAppBase class is to append "Page" to the name and look for that page in a .Views child namespace in the project. Alternatively, another convention can be specified by overriding the GetPageType method in the MvvmAppBase class. Please note that the OnLaunchApplication method returns a Task in order to allow it to launch a long running operation. If you don't have a long running operation to launch you should return an empty Task. App specific initialization behaviour is specified in the OnInitialize method in the App class. In the case of the sample app this involves registering types and instances that will be used in the view model constructors with the Unity9 dependency injection container. However, Prism for the Windows Runtime is not dependent on Unity. Instead you can register a factory with the ViewModelLocator object that will create a view model instance that will be associated with a view. For more info see Using Prism for the Windows Runtime4. C# protected override void OnInitialize(IActivatedEventArgs args) { method registers the FileSystemRepository type with This _container.RegisterType<IRepository, FileSystemRepository> the container, as a singleton, based on its interface, so that (new ContainerControlledLifetimeManager()); the view model classes can take a dependency on it. }

Because the sample app uses Unity, the Resolve method from the MvvmAppBase class is overridden in the App class to return a constructed view model instance. C# protected override object Resolve(Type type) { return _container.Resolve(type); }

This method override is used by the ViewModelLocator object to set a factory for the ViewModelLocator to use the container to construct view models so that their dependencies are injected. The ViewModelLocator object, provided by the Prism.StoreApps library, uses a convention-based approach to locate and instantiate view models from views. This convention assumes that view models are in the same assembly as the view types, that view models are in a .ViewModels child namespace, that views are in a .Views namespace, and that view model names correspond with view names and end with "ViewModel". The ViewModelLocator object has

protected override Task OnLaunchApplication(LaunchActivatedEventArgs args) { NavigationService.Navigate("Main", null); return Task.FromResult<object>(null); }

an attached property, AutoWireViewModel, which is used to manage the instantiation of view models and their association to views. In the view's XAML this attached property is set to true to indicate that the view model class should be automatically instantiated from the view class. XAML prism:ViewModelLocator.AutoWireViewModel="true"

The ViewModelLocator object uses this convention-based approach to resolve the correct view model type. The view model factory, set by the MvvmAppBase class, uses the dependency injection container to construct view model instances whose dependencies are injected by the container. When the view model instances are constructed, dependencies specified by the constructor parameters are resolved by the container and then passed into the view model. This approach removes the need for an object to locate its dependencies or manage their lifetimes, allows swapping of implemented dependencies without affecting the object, and facilitates testability by allowing dependencies to be mocked. If you run the app and navigate to the PhotoPage, and then suspend and terminate the app, on reactivating the app the previously loaded photo will be displayed. This is because the path to the photo is passed to PhotoPage as a navigation parameter, which is automatically serialized to disk by the Prism.StoreApps library when the app suspends. In addition, if you have view model properties whose values you want to survive termination, you should mark them with the custom [RestorableState] attribute. C# [RestorableState] public bool IsGreyscale { get; set; }

When the page is navigated away from the data contained in any properties marked with the custom [Restorable State] attribute is serialized to disk. Then when the app

is reactivated, any properties that are marked with the custom [RestorableState] attribute will have their values restored from disk. All this work is performed by the Prism. StoreApps library. For details of how Prism undertakes this operation see Handling suspend, resume, and activation12. SUMMARY Prism for the Windows Runtime can accelerate the development of Windows Store apps by providing support for MVVM and the core services required in Windows Store apps. For a bigger app that demonstrates all of the features of Prism for the Windows Runtime see Developing a Windows Store business app using C#, XAML, and Prism for the Windows Runtime2.

David Britch is a Principal Technologist at CM Group Ltd., and for the past two and a half years has been working on a number of projects with the patterns & practices group at Microsoft. David has authored and contributed to a range of recent software development publications including books, guidance documentation, and reference implementations.

REFERENCES 1 http://pnp.azurewebsites.net/en-us/ 2 http://msdn.microsoft.com/en-us/library/windows/apps/xx130643.aspx 3 http://msdn.microsoft.com/en-us/library/windows/apps/xx130645.aspx 4 http://msdn.microsoft.com/en-us/library/windows/apps/xx130642.aspx 5 http://www.nuget.org/packages/Prism.StoreApps/ 6 https://www.nuget.org/packages/Prism.PubSubEvents/ 7 http://code.msdn.microsoft.com/windowsapps/Prism-for-the-Windows-86b8fb72 8 https://onedrive.live.com/?cid=1b98b9a3cc9eb1aa&id=1B98B9A3CC9EB1AA%21198&ithint=file,. zip&authkey=!AAfxN7ip13lJtWA 9 http://msdn.microsoft.com/en-us/library/ff647202.aspx 10 http://msdn.microsoft.com/en-us/library/windows/apps/xx130647.aspx

LET’S GET PHYSICAL

with MonoGame and the Farseer Physics Engine On an average day you probably don’t notice the laws of physics, but you would if they went missing or changed suddenly. The world around you would stop feeling real. This is how a game can feel when the maker ignores physics or gets the rules wrong. By Richard Garside

Implementing these rules right can be tricky, which is why it’s often a good idea to stand on the shoulders of giants and use an existing physics engine. One such engine is the Farseer Physics Engine. The Farseer Physics Engine (FPE) is based on a well-known physics engine called Box2D originally written in C++. Although FPE was written for XNA, it also works with MonoGame. In this article we’re only really going to scratch the surface of what you can do with FPE. Although simple and easy to implement, the effects will be fantastic and newtonianally beautiful.

LET’S GET STARTED So, I’ve had a completely original idea for a physics based Windows 8 game. It’s called Angry Nerds. In this game you can pick up a nerd and throw him at a pile of other nerds. All the nerds will bounce and interact in a physically

realistic way. They will probably also become angry. After you’ve installed the latest version of MonoGame from www. monogame.net you can use the new MonoGame Windows 8 XAML project template in Visual Studio. Next, use nugget to install the MonoGame Windows 8 Farseer Physics Engine. You now have everything you need to get going. You can find the complete source code at: www.bitbucket.org/NogginBox/monogame-farseer-physics-engine-demo THE WORLD The FPE World is an object manager. It keeps track of all the physical bodies you create, how they interact over time and it also knows about gravity. In the main game class Initialise method; set up your world as a class field like so:

protected override void Initialize() { // Setup world with downwards gravity and add a border to stop us // loosing objects _world = new World(new Vector2(0, 1f)); var border = new SpriteBorder(_world, Window.ClientBounds); // Setup touch and enable make mouse visible IsMouseVisible = true; base.Initialize(); }

This gives the world normal downwards gravity. You can play with both the direction and the force of gravity. If you were making a table air hockey game you’d want to have zero gravity. I’ve also created a SpriteBorder to stop our Angry Nerds escaping the confines of the game. SpriteBorder is a class of my own creation that you can check out in the source code. It creates a loop shape body that our nerd bodies are inside and will bounce off. We’ll learn about bodies shortly. In MonoGame the game loop repeatedly updates the positions of all objects in the Update method. Our FPE World now takes care of most of this when we call step on it. We do this in the Update method in our main game class: // Variable time step but never less than 30 Hz _world.Step(Math.Min((ﬂoat)gameTime.ElapsedGameTime.TotalSeconds, (1f / 30f)));

Now we just need to add some bodies into this world and also touch controls that will introduce external forces to these bodies. SPRITE BODIES In a 2D MonoGame game we typically draw 2D textures to the screen as sprites. FPE lets us create bodies that we add to the world. A body has a position, a shape and properties like friction. In our example we will create a simple one, but you can create more complicated composite and jointed objects. We’ll create a new class called SpriteBody. This class will contain a FPE body that will deal with how our sprite physically behaves and it will contain a texture that we’ll draw to screen. FPE has a BodyFactory which makes the process of creating a number of common body types really easy. Our nerds are going to be circular so we need to create a circular body. I do this in the SpriteBody constructor: public SpriteBody(World world, Texture2D texture, Vector2 positionInPixels) { _body = BodyFactory.CreateCircle(world, radius: ConvertUnits.ToSimUnits(texture.Width) / 2f, density: 10f, position: ConvertUnits.ToSimUnits(positionInPixels)); _body.BodyType = BodyType.Dynamic; _body.Restitution = 0.8f; _body.Friction = 1f; _texture = texture; // The texture is drawn using top left coords, so work out offset to use _textureOffset = new Vector2(texture.Width / 2f, texture.Height / 2f); }

The BodyFactory can make several different types of bodies such as rectangles, loops, breakable bodies and many more. For us a circle will do just fine.

While using FPE it is easy to get confused about units. As many games will zoom in and out pixels are not always constant. So FPE uses sim units and when we get units in pixels from things like textures or from touch input we need to convert them to sim units. When we draw bodies to screen we need to convert the FPE sim units back to pixels which are display units.

ALL DONE So, hopefully you can see that using FPE in your game is really simple. All you need to do is create your physical bodies, apply forces to them and then call Step on the World to update everything. FPE then does all the hard work keeping track of your bodies’ movement and interactions with each other. It’s very easy and the results are very impressive.

Her are three FPE static methods that deal with sim and display units: ConvertUnits.SetDisplayUnitToSimUnitRatio(displayUnitsPerSimUnit); ConvertUnits.ToDisplayUnits(simUnits); ConvertUnits.ToSimUnits(displayUnits);

You only really need to set ratio if you change the zoom level on your game. In Angry Nerds it stays the same so we can ignore that for now. In this constructor we also store a texture and work out an offset for it because the origin in FPE is the centre of our object, but for drawing textures it is the top left corner. DRAWING OUR SPRITEBODY The draw method for SpriteBody is very simple: public void Draw(SpriteBatch spriteBatch) { spriteBatch.Draw(_texture, ConvertUnits.ToDisplayUnits(_body.Position) - _textureOffset); }

Our FPE body knows its Position, so all we need to do is convert that to display units to show on the screen. UPDATING OUR SPRITEBODY The FPE world will keep track of any internal forces and the movement of our bodies, but if we want to introduce external forces then we need to apply these. In Angry Nerds a player can touch and drag a nerd. They are effectively applying a force to the nerd. If a nerd is dragged we apply a force using this method: public void UpdateApplyForce(Vector2 forceInPixels) { _body.ApplyForce(forceInPixels * 5); }

The force is a vector containing the x and y component of the delta of the drag motion in pixels. I’ve multiplied this by 5 to give the drag action some welly. The drag action input is collected in the main game class. You can see how this works by downloading the source for this sample.

Richard Garside is a freelance mobile/web developer who likes to make games in his free time. You can find out more about him at his website www.nogginbox. co.uk and you can find out about his latest MonoGame game at www. towerblocks.net

FsCheck:

smarter validation with Property-based testing Monday, 9 am. Oscar, developer at Initech, has been given the following task: implement a password-strength validator for the website. The current requirements are minimal: a password shorter than 8 characters should not be valid. By Mathias Brandewinder

Oscar knows that requirements have a way of changing over time, and proceeds to write an extensible validator:

public interface IRule { bool IsSatisfied(string password); } public class MinLength : IRule { public bool IsSatisfied(string password) { return password.Length >= 8; } } public class Validator { private readonly IEnumerable<IRule> rules; public Validator(IEnumerable<IRule> rules) { this.rules = rules; }

}

public bool IsValid(string pwd) { return this.rules.All(x => x.IsSatisfied(pwd)); }

Oscar is a serious engineer, and wouldnâ&#x20AC;&#x2122;t ship anything untested, so he also adds some tests, using his favorite language, F#: [<Fact>] member test.``When length is < 8 rule is not satisfied`` () = let pwd = "1234567" let rule = MinLength() Assert.False(rule.IsSatisfied(pwd)) [<Fact>] member test.``When length is >= 8 rule is satisfied`` () = let pwd = "12345678" let condition = MinLength() Assert.True(condition.IsSatisfied(pwd))

ÂŠ bloomua/Shutterstock

[<Fact>] member test.``When a rule fails, password is not valid`` () = let rule = { new IRule with member this.IsSatisfied(pwd) = false } let validator = Validator([rule]) Assert.False(validator.IsValid("anything"))

This is all fairly typical code: a couple of unit tests, checking for positive and negative cases on concrete implementations, and stubs to validate against interfaces. This works great in most

situations, but one could make the following comment: the tests don’t do exactly what they say they do. If I were to tell you “I saw one black dog, therefore I validated that all dogs are black”, you would probably point out that my logic is flawed. And yet, this is precisely what we do here: to prove that all passwords of length greater than 8 are valid, we simply check one arbitrary example, and leave it at that. Of course, we cannot really prove the general statement, but verifying it on a wider range of cases rather than this particular one would reinforce our confidence. The reason we don’t is that it would be painful to manually generate more cases. But then, we are software engineers, and what software engineers do is automate anything that can be automated. This is where FsCheck, an F# testing library inspired by Haskell’s QuickCheck, comes in. Instead of relying on individual test cases, you supply FsCheck with general properties that should be true about your code, and let the library try to prove you wrong by generating test cases and validating them. As an example, here is how you could rewrite the first test:

right should also hold. Once that property is defined, it can be passed to Check.Quick, which will attempt to find counter-examples. In this particular case, the result will be “Ok, passed 100 tests.”; FsCheck cannot disprove your assertion. If we introduced a bug, for instance by changing the code to pwd.Length < 9, FsCheck would come back with the following: “Falsifiable, after 14 tests […]: "aaaaaaaa"”. Not only did it prove the existence of a bug, it even gave you a failing case. Pretty nifty! One of the interesting benefits of this approach is that it can simplify integration tests, and improve tests maintainability. While we validated the Validator (so to speak) using stubs, at some point, we might want to check that it actually works with the “real” rules. Imagine for a minute that we added requirements such as “should contain at least one digit, one upper-case character,…” and the like. Generating test cases for all the possible combinations is an incredibly tedious and error-prone activity. It is also fragile: any change in the requirements (“we actually need at least 3 digits”) will require a rewrite of all test cases. By contrast, you could let FsCheck do all the heavy lifting, by directly expressing your requirements:

let ``Password length < 8 is invalid`` (pwd:string) = let rule = MinLength() pwd.Length < 8 ==> not (rule.IsSatisfied(pwd))

Check.Quick ``Password length < 8 is invalid``

The first part defines a property that you expect to be true. The funky ==> operator represents a logical implication: if the premise on the left is true, then the conclusion on the 32

let ``check Validator`` (pwd:string) = let minLength = MinLength() let maxLength = MaxLength() let validator = Validator([minLength;maxLength]) (minLength.IsSatisfied(pwd) && maxLength.IsSatisfied(pwd)) ==> validator.IsValid(pwd)

For the sake of simplicity, I only added 2 rules, constraining the password to be at least 8, and at most 12 characters long – and omitted the reverse test. Instead of manually creating test cases covering all combinations, I can now simply feed the property to FsCheck, with the following result: “Arguments exhausted after 56 tests”. FsCheck generated 100 test cases, 56 of which satisfied the precondition, and passed the test. The beauty here is that if the requirements were to change (an unrealistic scenario, of course), and the maximum length were to become 16 characters, I wouldn’t have to recreate test cases or change anything. As a parting thought, consider now the following: imagine that I forced the minimum and maximum length to be, say, 8 and 6. What would happen? FsCheck produces the following result: “Arguments exhausted after 0 tests”. FsCheck generated 100 test cases, and couldn’t find a single one to validate against. Of course, this is an absurd requirement: no password can be simultaneously longer than 8 and shorter than 6. But that is precisely the point: all the pieces of code are behaving correctly in isolation, but put together, they are incoherent, and the Validator would never work. No amount of mocking will catch that, but FsCheck does.

Mathias Brandewinder has been developing software on .NET for about 10 years, and loving every minute of it, except maybe for a few release days. His language of choice was C#, until he discovered F# and fell in love with it. He enjoys arguing about code and how to make it better, and gets very excited when discussing TDD or F#. His other professional interests include math, forecasting, machine learning and probability. Mathias is a Microsoft F# MVP and the founder of Clear Lines Consulting.

So where does this leave us? My hope is that with this short example, I managed to convey why FsCheck is a great complement to traditional unit tests. There is much more to it than what I showed here, so I hope you’ll take a look, and figure out how to use it to make your code even better!

A Few Words on

Fluent API’s

As C# developers, we’re used to fluent API’s, even though we might not even know we’re using them. Let’s have a look at what they are, when they make sense, and how a basic implementation of this design principle looks. By Kevin Dockx

Let’s start out with a little bit of code. Imagine you have a collection of orders, and you want to filter that collection, and then sort it. To achieve that, you could write (pseudo) code like this, having different methods to sort and filter the collection that return the sorted, respectively filtered collection:

var myCollection = new List<Order>(); // add orders... // sort collection var myFilteredCollection = FilterCollectionByDate(myCollection); // filter sorted collection var mySortedAndFilteredCollection = SortCollectionByName(myFilteredCollection);

If we look at that code, we immediately notice it’s not exactly concise, nor is it very readable. What if we could write it as such: var myFilteredAndSortedCollection = myCollection.Where(...).OrderBy(...)

That should look quite familiar to most: we’ve just rewritten the first code sample as a fluent API. In fact, if you’ve ever used LINQ, you know what this is. A MORE EXACT DEFINITION Now that’s clear, we can have a look at a more exact definition – and where better to look than at what Martin Fowler has to say on the subject1? He describes the term “Fluent Interface” (often named fluent API) as an API designed primarily to be readable (cfr natural language) and to flow. It should then result in a more concise coding experience.

That said, creating a fluent interface for objects does increase complexity (slightly), but moreover: it definitely requires additional effort to design something like this. Therefore, it’s best suited for a specific set of requirements: mocking and configuration components2 or validation components3 are pretty good cases to consider a fluent API for, while the typical object instantiation (for example: a bunch of employees & their projects for the typical administrative application) probably isn’t the best use case to consider this for due to the added complexity & effort.

When I talk about complexity and effort, I’m not talking about the code required for this (as we’ll see later on, that part is pretty simple) – the complexity is more related to the amount of thought required to correctly design something like this. In reality, I often see these types of interfaces when designing a reusable, redistributable component.

GUIDELINES Now we know what it is & what good cases to consider it for are, we should have a look at the guidelines to consider. And this is where it gets… complicated, as there isn’t really agreement on this. In its most broad definition, a fluent API allows creating chains by returning the same type of output as it gets as input (if we’re starting from a collection, we should continue to work on that collection) and by allowing independent methods to be called on that input, in any order. That creates problems, of course. Let’s have a look at our example again: what if we want to add a .Sum to our sorted & filtered collection? That will no longer return the collection (input != output). We just broke our chain, but from a business point of view, it makes sense. And here’s another problem with that guideline: it’s easy to imagine a case where it doesn’t make sense that we can call any method in any order.

From where I’m standing, I’d say these guidelines are just that: guidelines, not requirements – but important guidelines nevertheless. With this in the back of our heads, I think it’s quickly becoming clear that designing something like this requires quite some effort, and therefore isn’t justifiable for all case. TECHNICAL IMPLEMENTATION But so far for the principles. After all this, you’re probably wondering how you can go about creating this yourself, right? From a technical point of view, this is a case of method chaining. In the following pseudo code sample (only the parts relevant to the fluent API are included!), I’ve created a custom collection type that supports method chaining for sorting and filtering through a FluentCollectionBuilder class:

public class MyCollection<T> : List<T> { private readonly FluentCollectionBuilder<MyCollection<T>, T> _collectionBuilder; public FluentCollectionBuilder<MyCollection<T>, T> Set { get { return _collectionBuilder; } } public MyCollection() { _collectionBuilder = new FluentCollectionBuilder< MyCollection<T>, T>(this); } public class FluentCollectionBuilder<TEnum, T> where TEnum : MyCollection<T> { private readonly MyCollection<T> _collection; public FluentCollectionBuilder(MyCollection<T> collection) { _collection = collection; } public FluentCollectionBuilder<TEnum, T> Sort<TKey>(Func<T, TKey> sortExpression) { // execute sort on the collection... SortCollectionByExpression(sortExpression);

NOTE: this code can of course be improved upon – it’s typed to our own collection type and works on implementations instead of interfaces, but it’s the most basic way to show how to implement method chaining, which is the purpose of this paragraph.

}

The method chaining is achieved by having the Sort and Filter methods return the FluentCollectionBuilder, which allows for further sorting, filtering, … Now, we can write code to filter and sort through our newlycreated fluent API: var myCollection = new MyCollection<Order>(); myCollection.Set.Filter(order => order.Name == "Laptop").Sort(order => order.OrderDate);

And that’s all there is to it, from the technical POV. Note that this is of course just one way to create a Fluent API – other implementations go a bit further and use, for example, extensions methods on IEnumerable<T> which would in turn call a method on the FluentCollectionBuilder to filter, sort, … that allows method chaining in existing collection types instead of having to create our own collection type. While implementations can differ, the principle remains the same: we enable method chaining through methods that return the class instance they’re working on. CONCLUSION In conclusion: fluent API’s aren’t suitable for all cases, but they do make sense for some cases like configuration, validation components, … While the guidelines of what makes for a good fluent API are somewhat unclear and debatable (and, in fact, not followed by any of the fluent API’s I’ve seen, not even LINQ), the main reason for their existence is better, more natural readability & flow. From a technical point of view, it’s a pretty simple case of method chaining, the true effort and complexity lies in correctly designing an interface like this, and not in the code itself. Happy coding! :)

Kevin Dockx lives in Antwerp (Belgium) and works at RealDolmen where he is a 32-year old Solution Architect, focussed on mobile in general & .NET/XAML in particular.

REFERENCES 1 http://martinfowler.com/bliki/FluentInterface.html 2 https://github.com/maartenba/MvcSiteMapProvider 3 http://fluentvalidation.codeplex.com/

He's a Microsoft MVP (Client Dev), a Pluralsight, bestselling book & article author, board member of the RD MS Community, and a regular speaker at various (inter) national events.

// return "this" to allow method chaning return this;

public FluentCollectionBuilder<TEnum, T> Filter(Func<T, bool> filterExpression) { // execute sort on the collection... FilterCollectionByExpression(filterExpression); // return "this" to allow method chaning return this; }

20. Mars this year, ProgramUtvikling successfully organized the “Architecture Day” event, with Neal Ford, Mark Richards and Venkat Subramaniam as the main speakers. The Architecture Day event was a full day focused on topics such as the journey from developer to architect, expectations for and the roles of an architect, software design architecture and principles and much more. By Dervis Mansuroglu

The technical depth

One of the talks was the relation between technical depth and breadth of an architect and why it so important to know the difference between them. In this article I will summarize this topic, which is relevant for not only architects but also for developers. A good architect is an architect who knows the pros and cons about many topics – not an architect who is an expert on everything or a single technology. The knowledge that an architect have has to be maintained, while at the same time investigating and identifying topics the architect don’t know anything about. The relation between what you do know and what you don’t know can be illustrated with the following triangle:

In the middle of the triangle, which is a part of your technical breadth, is the area where you have information about everything else. This is typically things you have analyzed and identified without have an in-depth knowledge. The latter, could for instance be pros and cons of some certain technology or platform. At the bottom of the triangle is a huge area of knowledge that you don’t know you don’t know. In theirs talks, Neal Ford and Mark Richards recommended that an architect should investigate, stay updated and identify knowledge without becoming an expert on every bits and details of that technology. Doing that, you will be able to lift unknown

and breadth of an Architect The figure shows the relationship between technical depth (things you know a lot about and your expertise) and technical breadth (things you know about but are not expert on). On top of the triangular, which is also the smallest of size, is your technical expertise. Knowledge in this area is typically things you work on a daily basis or information you have gathered through the years and you can easily explain and learn it to others.

unknowns to the middle of the triangle and hence expand your technical breadth. With time and experience you might one day lift that knowledge to the top of the triangle and make it become a part of your technical depth.

stronger in architectural discussions and also makes you a better leader. The overall advantages of this is that you become a better problem solver and makes you able to discuss technologies by showing examples and differences without actually being an expert on those technologies. Therefore, focus on the middle part of the triangle – that is – information you know about and lift more knowledge from the unknown unknowns to the known unknowns, Mark Richards explained. Finally, I want to cite Neal Ford’s comment about an architect’s knowledge: An architect should understand why things work, not the mechanics of how they work.

Dervis is senior Java developer, a technology and community enthusiast, active member of JavaBin, blogger, open source coder. He works for Inmeta Consulting in Oslo Norway and has almost five years of experience with front and backend development from sectors such as banking, healthcare, energy and media.

The illustration also shows that technical breadth in fact is the sum of your expertise and the information that you only have some knowledge about. A good technical breadth makes you

Inspiring SINCE 2008 Developers

Oslo Spektrum

mix and match Get all access to a whole week of inspiration or mix and match as you like Ticket types

Price

2 DAYS OF WORKSHOPS 3 DAYS OF CONFERENCE TALKS

All Access Pass (Workshops + Conference) 3 Day Conference Pass 2 Day Conference Pass 1 Day Conference Pass

NOK 18500 NOK 11500 NOK 10000 NOK 8500

2 Day Pre-Conference Workshop Pass 1 Day Pre-Conference Workshop Pass

NOK 9800 NOK 6800

Keynote: Luke Wroblewski (US)

2 Day Pre-Conf. Workshop + 1 Day Conf. Pass 2 Day Pre-Conf. Workshop + 2 Day Conf. Pass

NOK 13000 NOK 16000

25% VAT will be added to all ticket types.

be inspired

ndcoslo.com

The articles and presentations about functional programming usually list such FP advantages as high order functions, data immutability by default, pattern matching and terse syntax. Some functional languages are also capable of implicit type declaration, known as type inference.

ADD NEW DIMENSIONS TO YOUR ALGORITHMS USING F# TYPE INFERENCE

Type inference has also been available for local variables in C# since the version 3.0, as shown in this statement: var n = 42;

It works in a similar way in F#:

By Vagif Abilov

let n = 42

But in F# type inference goes far longer than that. You can infer function arguments in the same way: let sum x y = x + y

Execute the above line in F# Interactive, and it will show how it resolved parameter types for the function “sum”: val sum : x:int -> y:int -> int

In this case the arithmetic operator “+” gave F# Interactive a hint that it’s dealing with numbers, and it chose “int” type for them. If the code doesn’t provide any hint about parameter data types, then the arguments stay generic and the function can be used with any type:

let make_tuple x y = (x, y)

Response from F# Interactive: val make_tuple : x:'a -> y:'b -> 'a * 'b

So far it looks like a code typing convenience: when defining F# functions, we don’t need to be explicit about its parameter types (unless we want to override default behavior), so we will end up with more compact code which is a well-known advantage of most functional languages. But there’s much more power in type inference than possibility to omit type definitions. Unlike object oriented languages where generic algorithms and data structures require writing code in a certain way, type inference in functional languages allows generics happen implicitly, without special effort or attention. And this may lead to interesting discoveries. Let’s look at an F# implementation of the Conway’s Game of Life – a zero player game that models evolution of life within a two-dimensional board. The game is played according to the following rules (taken from Wikipedia): 1. Any live cell with fewer than two live neighbours dies, as if caused by under-population. 2. Any live cell with two or three live neighbours lives on to the next generation. 3. Any live cell with more than three live neighbours dies, as if by overcrowding. 4. A ny dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

Below is a possible F# implementation of the game: let neighbours (x, y) = [ for i in x-1..x+1 do for j in y-1..y+1 do if not (i = x && j = y) then yield (i,j) ] let isAlive pattern cell = pattern |> List.exists ((=) cell) let aliveNeighbours pattern cell = neighbours cell |> List.filter (isAlive pattern) let survives pattern cell = aliveNeighbours pattern cell |> List.length |> fun x -> x >= 2 && x <= 3 let reproducible pattern cell = aliveNeighbours pattern cell |> List.length = 3 let allDeadNeighbours pattern = pattern |> List.collect neighbours |> Set.ofList |> Set.toList |> List.filter (not << isAlive pattern) let nextGeneration pattern = List.append (pattern |> List.filter (survives pattern)) (allDeadNeighbours pattern |> List.filter (reproducible pattern))

Now to test the implementation we need to define a test pattern: let pattern = [(1,1);(1,2);(2,3);(2,4)]

So if we now execute nextGeneration function: nextGeneration pattern

we will receive the following output: val it : (int * int) list = [(1, 2); (2, 3); (1, 3); (2, 2)]

Have a closer look at the implementation. Can you spot a place where it says that it’s an implementation for a twodimensional board? When I talk about Conway’s Game of Life at a live presentation, I usually ask this question after scrolling down the page a little to hide the “neighbours” function. And it takes some time before somebody from the audience says “but you hid the “neighbours”! That is the only function which exposes number of board dimensions.” Yes it is. There is no other place in the algorithm that says anything about whether we are implementing the Conway’s Game of Life for two-dimensional board, threedimensional board or maybe even the space without geometrical dimensions. The algorithm can be used for any space abstraction as long as we define the meaning of a neighbour. Here’s how it will look for three-dimensional board:

let neighbours (x, y, z) = [ for i in x-1..x+1 do for j in y-1..y+1 do for k in z-1..z+1 do if not (i = x && j = y && k = z) then yield (i,j,k) ] let isAlive pattern cell = pattern |> List.exists ((=) cell) let aliveNeighbours pattern cell = neighbours cell |> List.filter (isAlive pattern) let survives pattern cell = aliveNeighbours pattern cell |> List.length |> fun x -> x >= 2 && x <= 3 let reproducible pattern cell = aliveNeighbours pattern cell |> List.length = 3 let allDeadNeighbours pattern = pattern |> List.collect neighbours |> Set.ofList |> Set.toList |> List.filter (not << isAlive pattern) let nextGeneration pattern = List.append (pattern |> List.filter (survives pattern)) (allDeadNeighbours pattern |> List.filter (reproducible pattern))

Note what’s changed: only the “neighbours” function! The rest is identical. But can we rewrite the algorithm to support multiple board dimensions at the same time? Yes we can. Enter F# discriminated unions and pattern matching:

type Cell = | Line of int | Surface of int * int | Space of int * int * int | Spacetime of int * int * int * int let neighbours cell = match cell with | Line(a) -> [ for i in a-1..a+1 do if not (i = a) then yield Line(i) ] | Surface(a,b) -> [ for i in a-1..a+1 do for j in b-1..b+1 do if not (i = a && j = b) then yield Surface(i,j) ] | Space(a,b,c) -> [ for i in a-1..a+1 do for j in b-1..b+1 do for k in c-1..c+1 do if not (i = a && j = b && k = c) then yield Space(i,j,k) ] | Spacetime(a,b,c,d) -> [ for i in a-1..a+1 do for j in b-1..b+1 do for k in c-1..c+1 do for l in d-1..d+1 do if not (i = a && j = b && k = c && l = d) then yield Spacetime(i,j,k,l) ]

I skipped the rest of the algorithm – it’s identical to previous implementations. Now we can write unit tests for our multi-dimensional implementation that will verify behavior for both 2D and 3D boards:

[<Test>] member this.``Square in 3d should not change``() = let pattern = [Space(1,1,0); Space(1,2,0); Space(2,1,0); Space(2,2,0)] pattern |> nextGeneration |> should equal pattern [<Test>] member this.``Cube in 3d should die``() = let pattern = [Space(1,1,1); Space(1,2,1); Space(2,1,1); Space(2,2,1); Space(1,1,2);Space(1,2,2) Space(2,1,2); Space(2,2,2)] pattern |> nextGeneration |> should equal List.empty

But wait – we don’t need to restrict us to geometrical distances between cells. We can implement Conway’s Game of Life for colors! We just need to throw a definition of neigbouring colors:

Again, the remaining part of the algorithm is a verbatim copy of our original definition, so I skipped that. To test the implementation, we’ll define a test pattern: let pattern = [Red;Green;Orange;Black]

… and execute the “nextGeneration” function: nextGeneration pattern

Here’s the result of the execution: val it : Color list = [Red; Orange]

While you have support for generics in C#, you don’t have the same implementation transparency due to lack of type interference. Specialized implementations in C# are more straightforward (and smaller in size) than generic ones, so developers usually begin with specialized algorithms and data structures and only convert them to generic implementations once they have needs for that. In F# it’s opposite: the functions are initially generic with type constraints applied only where they refer to functions with arguments or return values of specific types. And as we saw in examples above, such language capability leads to very high level of code reuse, including applicability to data types that we haven’t originally thought of.

Vagif Abilov is a Russian/Norwegian software developer and architect working for Miles. He has more than twenty years of programming experience that includes various programming languages, currently using mostly C# and F#. Vagif writes articles and speaks at user group sessions and conferences. He is a contributor to several open source projects and maintainer of a few ones, such as Simple.Data OData adapter, Simple.OData.Client and MongOData.

Software Development Oslo, Kjeller, Stavanger, Bergen

Schlumberger is a knowledge based company in the energy sector, with world class centers for Software Development located here in Norway. We have offices in Oslo, Kjeller, Bergen and Stavanger, responsible for delivering market leading software platforms for the oil-and gas industry. With more than 200 software engineers, we are a leading employer and competency center for software development in Norway. Our activities cover a wide range of activities, from software architecture, design, engineering to customer support, from technical documentation to quality assurance. We take great pride in our internationally diverse environment and our ability to consistently build innovative and integrated products with high quality. Schlumberger closely collaborates with Universities and Research Centers in Norway and throughout the rest of the world. All employees benefit from tailored and continuous training programs, state-of-the-art communication technologies and a global organization that supports knowledge sharing and team work. We encourage patent applications, conference participation and journal publications. For job opportunities, please contact sntc-recruiting@slb.com

Code Club for Juniors “You don’t have to be a genius to code – do you have to be a genius to read?” Bronwen Grimes, Technical Artist @ Valve By Olga Voronkova

When I was ten, my mother did something that changed my life – she asked my uncle to teach me how to code. Once a week we sat on the bus for an hour to get to his place, while I was working my way through the “Mastering QBasic by playing”, by Erny Casper. It was an exciting journey to another world. I still recall the feeling of pure fascination that what we wrote in text resulted in a fun game we could interact with (we made a bull race where the animations ran across the screen with random speed that was modified based on how well we answered different math riddles). I didn’t understand much of how it all worked, but I remember that it was really, really cool! There is a growing trend among programmers to pass their knowledge on to the children - for free, and on their own spare time. They are opening possibilities for the new generation to bypass us all in the future and become the technological wizards capable of spells we never dreamed of. As my uncle once taught me, so are many other uncles, parents, grandparents, friends, neighbours, friends of friends teaching kids they know and even kids they don’t know.

The code club movement code.org started in England, followed up by Norwegian enthusiasts in 2013. It spread like fire in just a few weeks after the initial “launch”, and local groups are continuously popping up

A group of children drew this after one of the code club workshops in their school

all across Norway. A colleague of mine asked me once to help out at Oslo Makers Faire with a Raspberry Pi workshop for kids. I didn’t really know how to talk to kids, let alone teach them something, but I had heard of the movement and was curious. Surprisingly, it went very well, the children were busy creating turtles and coding Minecraft, and were mostly explaining things to each other, only occasionally raising a hand for help. I think my favourite memory from that day is a group of 12 year olds who were so happy about every accomplished new task that they called for me each time and proudly demonstrated the results on the screen. Kids love to play, and have enormous amount of energy and imagination. When they catch the concept, they immediately start spinning on it, creating more and more advanced solutions. During one of the code club workshops in Nesodden, the teacher demonstrated a simple example of how to create lines of different colours by using a turtle from Python Turtle library. The kids listened, absorbed, and produced this:

Oslo Makers Faire is one of the arenas where kids can explore technology in Norway. Another upcoming big event is NDC Junior. This is the second year in a row that “Kodeklubben” - the Norwegian adaptation of U.K’s code club - is invited by NDC to arrange a special conference for kids. Last year we were 150 participants. This year we are expecting 300. Juniors from 8 to 18 years old will gather on top of Oslo Plaza to learn crafts of computing from code club volunteers - programmers, teachers, students, but most importantly - from each other. (www.ndcoslo.com/codingforkids) It’s important that juniors are not only the consumers of technology, but also its’ creators! We can all make a difference for the generation to come; we can introduce them to programming and how incredibly cool it can be. If you are still not convinced to start your own local code club, visit www. kidsakoder.no. There you can get start-up help and advice. It’s simple, easy and fun. All you need is a location, material (a lot can be found on kidsakoder web-site), a couple of grown-ups to watch over your shoulder, and of course kids (yours, neighbours, strangers - it doesn’t really matter).

Olga Voronkova is a fresh graduate from University of Oslo and developer at Computas. She likes puzzles, apps, pink, free food and turtles.

OpenID Connect: Unifying Authentication and Delegated API Access

The authentication and authorization story is currently quite fragmented – on one hand there are the “dinosaurs” like SAML2p and WS-Federation which do a good job in authenticating users in classic Web SSO scenarios, but are not really usable in e.g. native mobile applications. On the other hand there is OAuth2, which is useful for delegated Web API access but cannot be used for authentication (at least not without more or less secure proprietary extensions). OpenID Connect unifies both worlds and makes it much easier to implement authentication and API access in modern applications. By Dominick Baier

AUTHENTICATION, SINGLE SIGN-ON AND FEDERATION In corporate environments, the prevalent technology stack for implementing authentication and SSO is SAML2p and WS-Federation both based on SAML assertions, XML and XML digital signatures. All these technologies are proven and mature but they are also overly complex and at the end of their innovation lifecycle – to quote the popular identity analyst Craig Burton: “SAML is the Windows XP of Identity. No funding. No innovation. People still use it - but it has no future. SAML is dead != SAML is bad. SAML is dead != SAML isn’t useful. SAML is dead means SAML != the future.” Given the technologies we use today for building modern applications in browsers and for mobile computers, SAML is not really supported anymore.

In the meantime - OAuth2, which is a framework around requesting and using access tokens, gained quite a bit of traction. It was designed for native, web and browser

based applications right from the start and can be implemented by any device that has an HTTP stack. It lacked some well-defined “profiles”, a token type specification and was not really capable of interoperable authentication on its own. This is where the OpenID Foundation and OpenID Connect comes0 in. OPENID CONNECT OIDC (in short) is an extension to OAuth2 that adds authentication and interoperability features. Specifically three important things were added or specified. IDENTITY TOKEN OAuth2 already has the notion of an access token. This token is opaque to the client and is meant to be sent to some API backend. OIDC adds another token type called the identity token. The identity token has a standard format (a JWT – JSON Web Token), uses standard crypto and has a defined set of claims. This token is specifically designed so that the requesting client can validate it and thus verify the identity of the user (see figure 1).

Figure 1 A JWT identity token containing information about the issuer (iss), client (aud), expiration (exp), user (sub) and authentication method (amr). See1 for a link to this useful JWT decoder.

SET OF STANDARD SCOPES AND CLAIMS OAuth2 uses the scope parameter to specify which resources the client wants to access. The actual scope values are to be defined by the implementer. OIDC adds a number of identity related standard scopes like profile or email. Each of these scopes in turn map to a set of standard claims like given_name, picture or gender. These scopes are used for constructing a consent screen so that the user can actually authorize the client application to access the personal data, as well as for creating an access token for the UserInfo endpoint. SCOPE

CLAIMS

profile

name, family_name, given_name, middle_name, nickname, preferred_username, profile, picture, website, gender, birthdate, zoneinfo, locale, and updated_at.

email, email_verified

address

phone

phone_number, phone_number_ verified

offline_access

requests refresh token

authorize?client_id=clientapp&redirect_uri=http% 3A%2F%2Flocalhost%3A21575%2Findex.html&response_ type=id_token&scope=openid

In plain English this means: “Hi – I am a client called clientapp (client_id=clientapp), please authenticate the user for me and send me back an identity token (response_type=id_token) containing the user id (scope=openid) to my application address (redirect_uri).” The resulting callback will look like this (again simplified):

USERINFO ENDPOINT Depending on the protocol parameters, claims can be directly returned from an authentication request (WSFederation style) or via a back channel (SAML2p artifact resolution style). OIDC also defines this back channel endpoint for requesting claims as well as its request/response format. It’s called the UserInfo endpoint. FLOWS Similar to “raw” OAuth2, OpenID Connect also uses so called flows to describe the interaction between various client types and the OIDC provider. The implicit ﬂow is for public clients that cannot (or don’t want to) authenticate with the provider – a native or JavaScript/browser-based application would be an example for that.

http://localhost/index.html#id_token=ey...ssq

The client can then extract the identity token and validate it. To make that process simpler, clients can also automatically discover the necessary key material to validate the signature. This is done via metadata that the OIDC provider can make available (very similar to WS-Federation or SAML metadata). Example 2: In addition to the user identifier, the client would also like to know the email address of the user as well as some profile information like first and last name. authorize?client_id=clientapp&redirect_uri=http% 3A%2F%2Flocalhost%3A21575%2Findex.html&response_ type=id_token&scope=openid%20email%20profile

This time the scope parameter also contains the values email and profile, and the resulting identity token will contain the requested values (if available). Also similar to OAuth2 it is possible for an OIDC provider to ask the user for consent before it releases the identity information (see figure 2).

Since OIDC is based on OAuth2, we get the API access for free. That’s great, especially since the identity token and the API access token can be acquired in a single roundtrip, e.g.: authorize?client_id=implicitclient&redirect_ uri=http%3A%2F%2Flocalhost%3A21575%2F index.html&response_type=id_token%20 token&scope=openid%20profile%20someApi.read%20someOtherApi.write%20email

Compared to the previous examples, there are some important differences here. First of all the response types is now “id_token token”, which means that we now request an identity token and an access token. Second, the scopes now contain OpenID specific scopes like profile and email, but also API scopes like someApi.read. The resulting callback will now contain both an identity token and the access token (as well as the access token expiration time): http://localhost/index.html#id_token=ey.. xz&token=sjs..rew&expires_in=3600

IMPLEMENTATIONS OpenID Connect v1.0 was released on February 26th 2014, so it is pretty new. Nevertheless, since the specifications were under development for quite a while, there are already a number of implementations for both OIDC providers as well as client libraries (including JWT validation and parsing). See2 for the official library and product list.

There’s a third flow, called the hybrid ﬂow, which can be used for application architectures that are a mixture of the above-described scenarios.

Example 1: A native/JS application requests authentication. The application only needs to know the unique user id of the user.

API ACCESS AND DELEGATED AUTHORIZATION So far we looked at authentication (aka “a client wants to know who the user is”), but the other big use case these days is delegated API access (aka “the client wants to access a back-end service on behalf of that user”). Sometimes we only need authentication and access the backend in a trusted subsystem manner, sometimes the client does not really care who the user is as long as it can access the back-end, and sometimes we need both.

RESOURCES http://openid.net/connect/ 1 http://jwt.io 2 http://openid.net/developers/libraries/ 3 https://github.com/thinktecture/Thinktecture.IdentityServer.v3 4 http://katanaproject.codeplex.com/ 5 http://osis.idcommons.net/wiki/Category: OC5_Participant 0

So in other words – using this approach we can use a single protocol for all application and client types to request authentication and access tokens. That’s very useful.

The code ﬂow is typically used for server-based applications that can securely store secrets and authenticate with the OIDC provider – this allows for additional features like refresh tokens.

SOME EXAMPLES Let’s have a look at some examples of typical OpenID Connect authentication requests. For simplicity we will use the implicit flow to describe the general protocol steps (and also omit some of the details).

If the identity token should be send to a server-based web application, the client can add a response_mode=form_post parameter which instructs the OIDC provider to package the token in an HTML form and post it to the callback address (again very similar to WS-Federation of SAML2p POST profile).

On the .NET/C# side of things we are currently working on IdentityServer v33 which is an open source OIDC and OAuth2 implementation, and Microsoft has already previewed OIDC middleware for Katana/ASP.NET4. Figure 2 Example of an OpenID Connect Consent Screen

Since the callback transmits the identity token via a hash fragment on the URL, this approach is only suitable to native or browser-based applications.

Since one of the main goals of OIDC is interoperability5, it should soon be trivial to combine heterogeneous clients and providers into a larger application architecture – which sounds good to me.

Dominick Baier is well known expert for identity & access control technologies and protocols. He shares his time between doing consulting for thinktecture (http://www. thinktecture.com), working on open source projects (http:// thinktecture.github.io), blogging (http://leastprivilege.com) and tweeting (@leastprivilege).

COURSE OVERVIEW OSLO

www.programutvikling.no

COURSETITLE AGILE Architecture with Agility - Kevlin Henney

Oslo

Price 18 900

Days Mai Jun Aug Sep Oct Location

Advanced C++ programming and Introduction to C++11 - Hubert Matthews

C++ for Embedded Developers - Mike Tarlton

5 2

Agile Interactions Workshop - Jessie Shternshus

Plaza

6 800

Scalable design and implementation using C++ - Andrei Alexandrescu

Hacking the Creative Brain - Denise Jacobs

Plaza

6 800

BDD - Specification by Example - Gojko Adzic

Oslo

14 900

SCRUM

Days Mai Jun Aug Sep Oct Location 2

Certified ScrumMaster - CSM - Geoff Watts

Trondheim

14 900

Certified ScrumMaster - CSM - Geoff Watts

Tromsø

14 900

Product Owner Survival Camp - Gojko Adzic

Oslo

14 900

Certified ScrumMaster - CSM - Mike Cohn

Oslo

14 900

Test-Driven Development - Venkat Subramaniam

Surviving Legacy Code - J.B. Rainsberger

Evolutionary Design and Architecture for Agile Development - Venkat Subramaniam - 16 Februar 2015

Oslo

14 900

16 Oslo

14 900

Days Mai Jun Aug Sep Oct Location

Test-Driven Development & Refactoring Techniques - Robert C. Martin - 10 November

DESIGN - ANALYSIS - ARCHITECTURES

Price

Certified Scrum Product Owner - CSPO - Mike Cohn

TEST-DRIVEN DEVELOPMENT

18 18

18 900

Oslo

24 900

Oslo

14 900

Days Mai Jun Aug Sep Oct Location 4

Oslo

Project Design Master Class with Juval Lowy

13 Oslo

Days Mai Jun Aug Sep Oct Location

Mobile to Multi-Device Web - Luke Wroblewski

Fundamentals of iOS Programming - Wei-Meng Lee

MICROSOFT

03 19

Identity and access control for modern web applications and APIs - Dominick Baier

C .NET: Utvikling av applikasjoner i .NET med C# - Arjan Einbu

Web Development in .NET - ASP.NET MVC , HTML5, CSS3, JavaScript - Arjan Einbu

WPF/XAML - 70-511 / 10262A Windows Presentation Foundation/XAML - Arne Laugstøl

Windows Azure Racing Game Workshop - Alan Smith SHAREPOINT SharePoint 2013 and Office 365: End to End for Developers - Sahil Malik JAVA

1 5

Programming in Java 8 - Venkat Subramaniam - 19 November

Programming Java Standard Edition - Eivind Nordby

Reactive Programming with Akka - Venkat Subramaniam - 17 November

JavaScript and HTML5 for Developers - Christian Wenz

JavaScript for programmers - Christian Johansen

AngularJS End-to-End SPA Development - Dan Wahlin

AngularJS and HTML5 - Scott Allen

AngularJS workshop - Scott Allen

PROGRAMMING

Oslo

Price 21 900

Days Mai Jun Aug Sep Oct Location

Objektorientert utvikling - Eivind Nordby

PRE-CONFERENCE WORKSHOPS AT NDC OSLO

Days Mai Jun Aug Sep Oct

Advanced PostSharp From the Horse´s Mouth - Gael Fraiteur

Oslo

Price 21 900

Location

Price

Plaza

6 800

Raw TDD - Kevlin Henney

Plaza

6 800

Getting Started with Apache Cassandra - Tim Berglund

Plaza

6 800

Lean Startup: Your Minimum Viable Product (MVP) Sucks! - Tristian Kromer

Plaza

6 800

Designing and implementing Web APIs in the .NET platform - Pablo Cibraro & Pedro Félix

Plaza

9 800

GitHub Intro + Advanced - Fryman, Graham & Olsson

Plaza

9 800

Agile Interactions Workshop - Jessie Shternshus

Plaza

6 800

AngularJS workshop - Scott Allen

Plaza

9 800

Identity and access control for modern web applications and APIs - Dominick Baier

Plaza

9 800

Mobile to Multi-Device Web - Luke Wroblewski

Plaza

6 800

Windows Azure Racing Game Workshop - Alan Smith

Plaza

6 800

Price

Oslo

21 900

XML

Days Mai Jun Aug Sep Oct Location

Exchanging and Managing Data using XML and XSLT - Espen Evje

Parking Entrance

Price 18 900

Oslo

24 900

Oslo

21900 18 900

Oslo

18 900

Oslo

21 900

Oslo

21 900 9 800

Price 18 900

ProgramUtvikling AS is located in the IT-Fornebu technology park at Snarøya.

ENROLMENT OPTIONS Bus stop

Price

Oslo

Our offices and course rooms are situated in the terminal building of the former Oslo airport. The photo shows the car park, bus stop and course rooms. For details of bus times, go to trafikanten.no

24 900

Oslo

ADDRESS Martin Lingesvei 17-25, 1367 Snarøya.

Price

21 900

HOW TO FIND US PROGRAMUTVIKLING MAIN OFFICE, OSLO

6 800

Oslo

Plaza

Days Mai Jun Aug Sep Oct Location

Databasedesign, -implementering og SQL-programmering - Dag Hoftun Knutsen

24 900

Price 14 900

21 900

13 Oslo

Oslo

6 800

DATABASE

9 800

24 900

Days Mai Jun Aug Sep Oct Location

Plaza

Oslo

Days Mai Jun Aug Sep Oct Location

Deep C: Et kurs for erfarne C og C++ programmerere - Olve Maudal

Plaza

9 800

24 900

Plaza

Oslo

24 900

21 900

24 900

Plaza

6 02

Price

Oslo

Hacking the Creative Brain - Denise Jacobs

Oslo

Programming in Functional Style - Venkat Subramaniam

Oslo

Days Mai Jun Aug Sep Oct Location 4

21 900

6 800

Days Mai Jun Aug Sep Oct Location

Core Spring - Mårten Haglind

HTML5 - JavaScript - CSS3

Price

Plaza

Days Mai Jun Aug Sep Oct Location

70-513 - WCF 4.5 with Visual Studio 2013 - Sahil Malik

Price

Oslo

Agile Design and Modeling for Advanced Object Design with Patterns - Craig Larman - 12 januar 2015 MOBILE APPLICATIONS

C++ Days Mai Jun Aug Sep Oct Location

www.programutvikling.no - info@programutvikling.no Tel.: +47 67 10 65 65 - Fax: +47 67 82 72 31

www.programutvikling.no/feed/news.aspx

nyheter@programutvikling.no

facebook.com/programutvikling

Photo: Shutterstock

Agenda and Practical Information All you need to know about NDC 2014

>>>

• 3-day

conference with 9 parallel tracks • 2 days of Pre-Conference Workshops

We develop developers Training and conferences in Oslo and London ProgramUtvikling offers the best courses and most flexible training to the developer community wherever you want us to. Our philosophy is to provide “practical, applicable knowledge” by providing the highest quality training with the best instructors. In addition to our permanent staff we have a number of exciting and well-known instructors such as Herb

Sutter, Craig Larman, Billy Hollis, Mike Cohn, Geoff Watts, Gill Cleeren, Sahil Malik and a great staff of excellent Scandinavian instructors.

OSLO - www.programutvikling.no

NDC has become one of the largest conferences dedicated to .NET and Agile development and is hosted by ProgramUtvikling AS. www.ndcoslo.com www.ndc-london.com

ndcoslo.com

THE AGENDA COMMITTEE

NDC Oslo is reaching new hights

The inspiring conference for developers will be held in Oslo spektrum for the seventh year in a row. By Charlotte Lyng

Once again the NDC Agenda Committee has worked hard to select the very best among a mountain of suggested sessions and topics. We've tried to find interesting speakers of high quality that is new to NDC, and we've used

TORBJØRN MARØ, CTO AT PSWINCOM Torbjørn Marø is the CTO of a mobile communications company in Norway. He is a passionate coder, and loves to learn and use new (and old) programming languages and technologies. As an active blogger he tries to share his excitement for software with anyone who's willing to listen. "As always I'm looking forward to meeting a host of like minded and interesting people at NDC. I think the various topics and talks we have been able to select this year is amazing, and there will be something of interest to everyone attending." "I'm especially happy with the attention given to functional programming this time around. The industry is finally beginning to see the importance and opportunities of this paradigm, and it's only going to become more important as we go forward."

feedback from earlier years to improve what is already a great conference. The agenda reflects what developers are most concerned with in 2014, and while it will still be familiar you'll find the conference program more versa-

JONAS FOLLESØ, MANAGER AND SCIENTIST IN BEKK Jonas started programming the moment he got his first computer as a 11 year old, and after working with .NET for 11 years he has gained broad experience and in– depth knowledge of the .NET Framework and the C# programming language. Over the last few years one of his passions has been for programming languages in general, and functional programming in particular. Jonas is currently working for BEKK as a scientist and manager, doing both project-work as well as keeping track of new technologies and techniques for software development. Jonas is an active member of and contributor to the Norwegian developer community. He is an experienced speaker from both local user groups and larger conferences like TechEd, REMIX, MSDN Live, JavaZone, Smidig, ROOTS, Functional Programming Day and NDC. He has also been a member of the NDC program committee for the last 4 years.

tile than ever before. We hope you are as exited as we are about this, and that NDC 2014 will give you the inspiration and knowledge to face new challenges and do interesting and great things with technology!

TORSTEIN BJØRNSTAD, SENIOR CONSULTANT AT WEBSTEP Torstein Bjørnstad is a consultant focused on helping clients take use of modern web technology in order to provide rich and interactive user experiences to their users. He spends his spare time diving into and evaluating new technologies in his many fields of interest. This is Mr Bjørnstad's second year in the agenda committee, and his focus is to represent the views of developers working with the .NET stack. "I have attended NDC for four years now, and I am very excited about this year's agenda. It might be a bit less centered on Microsoftbranded technologies and frameworks than earlier years, but instead it has more talks on patterns and practices which is relevant to everyone, and in my opinion more important. I am especially looking forward to this year's talks on functional programming and language alternatives to C#. My challenge to you as an attendee is to dare step out of your comfort zone and attend talks on topics you are not too familiar with, and get inspired!"

OLVE MAUDAL, MINISTER OF KNOWLEDGE AT CISCO SYSTEMS Olve Maudal works for Cisco Systems where he is involved in developing collaboration technology, in particular video conferencing products and telepresence solutions. He loves to write code, but he is just as interested in how software is developed as what it actually does. Main interests are C, C++, TDD, secure coding and software architecture. “We have established a very strong two day C++ track for NDC 2014, with Nico Josuttis, Andrei Alexandrescu, Hubert Matthews and Sccott Meyers as headliners. Learn more about modern C++, move semantics, type deduction, memory models, embedded, security, and tools. This is a unique opportunity to get deep insights into modern C++ from top trainers and industry experts. You can even combine the conference with twoday pre-conference course by Andrei - "Scalable design and implementation". BRYAN HUNTER, FOUNDER OF NASHVILLE FUNCTIONAL PROGRAMMERS Bryan Hunter is the CTO of Nashville-based Firefly Logic, and a functional programmer (Erlang, F#, and Elixir). He is a Microsoft MVP in F#, and founded the polyglot functional programming group NashFP. Bryan volunteers much of his free time to promoting functional programming through community building, developer events, and business-leader education. This is the first year that Bryan is part of the NDC programme committee. He was brought in to organize a full three-day functional programming track within NDC Oslo. When you

see the line-up you will agree he has done very well. "NDC has a big influence on developers all over the world. I learned of NDC Oslo in 2007, and each year since I've taken vacation days to watch the session videos. For many companies in Tennessee (my home), NDC defines 'best practice', and what 'normal' should look like. I am so thankful and honored to be included in the mix this year. I believe that we as an industry are at a tipping point where functional programming becomes mainstream; becomes the norm; becomes the 'safe option'. I can't imagine a better ribbon cutting/liminal moment than when Joe Armstrong takes the stage at NDC. My God, it's full of stars!" BODIL STOKKE, SERIAL CONFERENCE ORGANISER AND DEVELOPER AT COMOYO Bodil is a frequent speaker at developer conferences internationally, and helps organize the Web Rebels and flatMap(Oslo) conferences, and two local meetup groups, in addition to serving on the agenda committee for NDC. She is a profilic contributor to the Free Software community, primarily as a Clojure developer, and has recently taken up designing new programming languages as a hobby. In her spare time she works as a web developer for Comoyo. “My aim has been to help NDC lose its reputation for being a purely .NET conference and diversify into areas like the Web and functional programming. I`m pleased to report that in addition to the regular agile and enterprise fluff, this year`s NDC has also gathered one of the best lineups for a functional programming conference I`ve seen in a long time. As a non- Microsoft developer, I am excited about this”.

JAKOB BRADFORD, GENERAL MANAGER OF PROGRAMUTVIKLING AND NDC Jakob Bradford has the main responsibility for seeing that the agenda committee reach their goal and the completion of the conference. “Both of the number and quality of the Call For Papers have been very high this year. We have received more abstracts from more speakers than ever. The high quality meant that we increased with an extra track, so that this year there will be 9 parallel tracks. The number of speakers and abstracts shows the position NDC has as we enter our seventh year. This year I am very much looking forward to presenting our four-day C++ track. KJERSTI SANDBERG, GENERAL MANAGER OF PROGRAMUTVIKLING Kjersti Sandberg is the founder of ProgramUtvikling AS, and has organized the NDC Conference from the very beginning. Her daily job is with the professional areas of sale, marketing and business development. Here role within this year`s agenda committee has been to liaise with speakers and present good ideas. “NDC Oslo is a full week event with Pre-Conference Workshops on 2-3 June followed by the conference days 4-6 June. This year we have added more discounted workshops+ conference ticket options, giving our delegates more flexibility to tailor their own NDC experience”.

SVEIN ARNE ACKENHAUSEN, INDEPENDENT CONSULTANT AND LECTURER Svein Arne Ackenh a u s e n wo r k s i n Contango Svein Arne Ackenhausen on Contango Consulting AS, a small consultancy company that delivers software services and training. Here he works mainly with .NET development assigments and courses. In addition to his daily consultancy work he works with the products ContinuouTests (Mighty Moose), AutoTest.NET and OpenIDE. "I am really looking forward to this years conference. There are so many brilliant people talking about so many interesting subjects. There will be a lot of functional programming this year with some really exciting speakers,

like Joe Armstrong. What he and his team did with Erlang is something any developer can learn from. We get to learn from them and engage in conversations with them after hours. So much to learn! The agenda as a whole is diverse and I believe that all attendees will leave the conference with a greater understanding of the field of software development."

schools to provide them with knowledge about Microsoft Technology. In addition, he is a very active coder and has a passion for graphic programming, algorithms and game development.

PETRI WILHELMSEN, TECHNICAL EVANGELIST FOR MICROSOFT Petri's daily work is on the Evangelist team at Microsoft Norge. He is responsible for reaching out to developers in Norway with Microsoft technology for developers, as well as working closely with universities and

down together, evaluate lecturers and which sessions we wish to select from Call for Papers, distribute them during the day and make tracks. It has been incredibly rewarding working with such a competent group of people as this year's agenda.

Training and Conference

C++

“My role has been to help NDC find lectures, themes and sessions for the agenda. This is a big job where we on the Committee must sit

2-6. June

VERY STRONG C++ TRACK AT NDC 2014 BDD - Specification by Example 12. June and 16. October in Oslo with Gojko Adzic This two day workshop teaches you how to apply emerging practices for managing requirements, specifications and tests in agile and lean processes to bridge the communication gap between stakeholders and implementation teams, build quality into software from the start, design, develop and deliver systems fit for purpose.

Surviving Legacy Code 18. September in Oslo with J.B. Rainsberger Working with legacy code remains difficult. We feel afraid to change it, but sometimes we have no choice. You can easily learn techniques to help you manage your risk, but where do you practise them? If you apply them directly to your project's most valuable and difficult legacy code, then your risk becomes greater, not less. J. B. Rainsberger gives you a safe code base in which to experiment and guides you through the confusing risk/reward decisions involved in living with legacy code. You will learn and practise several specific, safe techniques that you can start using on your own legacy code once you return to your project.

Agile Design and Modeling for Advanced Object Design with Patterns 12. January 2015 in Oslo with Craig Larman This popular, high–impact, and hands–on course on mastering advanced object–oriented design (OOD) and design patterns (primarily the “Gang of Four” design patterns) with agility is aimed at architects and developers of OO systems, You will learn to design with patterns, apply visual modeling in an agile modeling approach, and a suite of related advanced design topics, including the design of packages. This course is based on acclaimed industry leader Craig Larman’s extensive experience coaching and applying OOD since the mid 1980s.

Scalable design and implementation using C++ with Andrei Alexandrescu This course teaches advanced topics in designing and implementing large, scalable systems using C++. Performance and system-wide robustness are primary concerns. New features of C++ (and idioms they enable) that help reduce boilerplate and make complex system implementations will be discussed.

NDC Oslo - A 5-Day Knowledge Boost! With 13 Pre-Conference Workshops, 9 Conference tracks with 172 sessions NDC is a week packed with knowledge. You can choose everything from a 1 Day ticket to all 5 days with the All Access Pass including training, workshops and the conference. Whatever you decide, we hope to see you in Oslo in June!

NDC WORKSHOP 2 days

2-3 June

Scalable design and implementation using C++

Andrei Alexandrescu

NDC CONFERENCE C++ Day 1

4 June

C++14 Effective Modern C++ Error Handling in C++ Move, noexcept, and push_back() and how they relate to each other C++ Type Deduction and Why You Care Template Meta-programming in C++

Nico Josuttis Scott Meyers Andrei Alexandrescu

NDC CONFERENCE C++ Day 2

5 June

C++ - where are we headed? Three Cool Things about D The C++ memory model C++ for small devices Brief tour of Clang Insecure coding in C and C++ For C++: When in doubt, do as the ints do

Hubert Matthews Andrei Alexandrescu Mike Long Isak Styf Ismail Pazarbasi Olve Maudal Anders Knatten

Course at OSLO PLAZA

WORKSHOP 2 DAYS NOK 9 800 + VAT WORKSHOP 2 DAYS + NDC CONFERENCE 1 DAY NOK 13 000 + VAT Andrei Alexandrescu

Nico Josuttis Scott Meyers Andrei Alexandrescu

Conferences at OSLO SPEKTRUM

Nico Josuttis

WORKSHOP 2 DAYS + NDC CONFERENCE 3 DAYS (ALL ACCESS PASS) NOK 18 500 + VAT

For complete course descriptions, time and place, visit www.programutvikling.no See course description at programutvikling.no and conference agenda at ndcoslo.com 60

WORKSHOP 2 DAYS + NDC CONFERENCE 2 DAYS NOK 16 000 + VAT

U O Y N I A T R E LET US ENT

ng ssions and an intrigui se l lle ra pa e or m en s, ev nce. ultiple dining choice , entertaining experie ng iri sp in With grand music, m an be to 2014 is destined expo area, NDC Oslo June 5th, The Tide ﬂows onto the Oslo Spektrum stage to rock NDC Oslo developers.

By Inger Renate Moldskred Stie

THE TIDE FLOWS IN Washed ashore the banks of Oslo and onto the Oslo Spektrum Stage, are the the dynamic and exciting four piece band The Tide. Get ready for an incredible, high-octane stage performance, as the music flows through the expo area of NDC Oslo, Thursday June 5th. The Tide, based in London's West End, produce an “all out assault on your musical senses with their powerful display of pure, unadulterated rock n' roll”. The band has over twenty years live experience, drawing inspiration from bands such as The Police, Aerosmith, The Beatles, Green Day, Lou Reed, Pink Floyd, Primal Scream, The Stones, The Clash and more recent bands The Killers and Kings Of Leon.

Find your user group at NDC Oslo During breaks, please make sure to visit the many stands in the expo area. And between mouthfulls, remember to visit the User group area to find out

Founding members Dean Sharp and Jamie Taylor started out as early as 1991 with various school bands and projects. Together they started writing lyrics, and Deans track called Sky High got the initial interest for the band going. Playing on the Oslo Spektrum stage are Dean Sharp on vocals and Rhythm Guitar, Jamie Taylor, lead guitar; Stefan Marinov, on bass guitar and finlly Alberto Voglino on drums.

Said about The Tide

“Beyond F*@king Amazing.” “The Best Saturday night band we've seen in ages, if not ever!” “One of the, if not the, ﬁnest covers bands in London.” “...our most dynamic and exciting band, The Tide.” With The Tide on shore, everything is set for a great musical experience at NDC Oslo.

KATZENJAMMER

more about the work of the different user groups. Maybe you’ll find one(or more) where you would fit in, or perhaps get inspired to start your own?

9th parallel session The variety of dishes match the variety of sessions to choose from and attend. With a 9th(!) parallel session this year; 9 rooms with diverse and different topics addressed, there is bound to be something up your alley. For the extra indecisive, all the sessions can be viewed from the Over-

flow Area: Swap between sessions with one click. Prior to the concert on Thursday is the usual panel debate. Don’t miss out on a potentially heated debate from our panel.

We’ve just got in some great news for you: Katzenjammer is now booked and will come and perform their mix of folk, pop, rock, country and balcan music. All is set for a great music experience at NDC Oslo.

Culinary Food from FCCircus Serving food throughout the conference, the Flying Culinary Circus bring you different dishesfor breakfast, lunch and dinner. Moving through the expo area you’ll pick up scents from a variety of cuisines. Find your favourites amongst these cuisines: SPANISH A variety of spanish tastes in a Tapa plate. INDIAN Get a spicy, fruity and culinary experience.

Introducing continuous delivery for SQL Server

JAPANESE Enjoy a freshly made sushi meal on your way to the next session. ITALIAN Grab an italian pizza on the fly.

Now you can bring the beneﬁts of continuous delivery to your database with these tools from Red Gate:

THAI Lush, fragrant dishes bound to trigger your taste buds. BRITISH Wild Wild London: British cuisine meets cowboy.

SQL SOURCE CONTROL

In addition, NDC Oslo keep a barista bar open throughout the day, for you coffee loving developers.

Connect your source control system to your database, for efﬁcient development

SQL AUTOMATION PACK

Automate database builds on your CI server, for fast feedback on your work

SQL COMPARE

The world’s most trusted tool for releasing SQL Server updates

BECOME A CERTIFIED SCRUMMASTER OR A PRODUCT OWNER 91% of the Fortune 100 and more than 650,000 end users worldwide use Red Gate.

ScrumMaster - Geoff Watts 2 days: 09. September Tromsø, 11 september Trondheim and 16 October Oslo

Download all three tools for free at www.red-gate.com/ndc

Certified Scrum Product Owner - CSPO - Mike Cohn 2 days: 04. June, 17. September and 17. December in Oslo

For complete course descriptions, time and place, visit www.programutvikling.no

Mike Cohn

Geoff Watts

Certified ScrumMaster - CSM - Mike Cohn 2 days: 02. June, 15. September and 15. December in Oslo

Oslo? Attending NDC oth for o it Red Gate’s b

Vis full process a demo of the

Oslo has a special combination of city life and easy access to the great outdoors. The city`s unique location means almost unlimited opportunities for fun, and these are some of the choices you have when spending time in Oslo:

The capital of Norway

TRYVANNSTUA If you got time to make it all the way to end of tram #1 on a sunny day, you should hitchhike in Nordmarka from Frogneseteren to the Tryvannstua lakes. Tryvannstua, which is a log cabin, built in 1931, is located by a small lake at the bottom of the ski slope Tranvannskleiva. The cabin is open year round and is the perfect place to try Norwegian pastries.

WHISKY BAR This whisky bar prides itself to have the finest selection of Irish, Scottish and world whiskies. With its enormous selection of Whiskies, good food, elegant décor and cosy friendly atmosphere, The Whiskey Bar is the ‘Whisky Haven’ you have been looking for in Oslo. You`ll find The Whisky Bar on Rådhusgata at the heart of Oslo`s evening scene. GRUNERLØKKA Grunerløkka is one of Oslo`s most popular boroughs. What started as a bohemian escape has turned into one of the most trendy parts of the city. Grunerløkka, commonly referred to as ‘Løkka’, is know for its

Oslo is a city full of contrasts. Its natural beauty, in combination with all the facilities of a modern metropolis, adds to the charm of a city often described as ‘the world`s largest village’. The surrounding countryside provides recreational opportunities for the city`s inhabitants and visitors all year round.

AKERSHUS FORTRESS Akershus Castle, also known as Akershus Slott, is a historic Norwegian landmark, located in the city centre by the Oslo Fjord. It is a great place to discover Oslo's history and a beautiful place to enjoy a summer day. Experience 700 years of history at Akershus Fortress with a guided tour. Guided tours are available every day in summer and on weekends in May and between mid-August and December.

FESTNINGEN RESTAURANT Elegant yet relaxed brasserie at Akershus Fortress with great views of City Hall Square and Aker Brygge. The restaurant is located in Akershus Fortress' old prison, building 22. Festningen Restaurant offers à la carte and multi-course menus for both lunch and dinner. The dishes are made of unique, seasonal ingredients from various parts of Norway. Here you can pop in for a quick lunch or enjoy a long dinner with great wine.

Tryvannstua cabin

creative atmosphere and numerous little cafes, restaurants and bars. The borough is also a popular shopping district with original design shops and many vintage stores. THE NORWEGIAN OPERA & BALLET Opera fan or not, this building in itself is worth a visit. Oslo`s new Opera House is shaped like an iceberg coming out of the water, and is the first opera house in the world that let visitors walk on the roof. Learn more about the architecture, stagecraft, opera and ballet through a 50-minute guided tour. SCHOUSKJELLERE MIKROBRYGGERI Imagine Norway in the time of the

Grünerløkka

vikings: A dim, candle-lit vaulted hall where mead was swigged from goblets, resting on long rustic wooden tables, all the while a massive fire roars away in the corner. Now replace the bearded barbarians with bearded Norwegian trendsetters, and the fermented honey water with in-house brewed beers and you have got the atmospheric setting of the schouskjelleren Mikrobryggeri brew-pub. The brewery is located underground in the cellar of the old Schous Brewery on Trondheimsveien. FRAM MUSEUM The Fram Museum is dedicated to the story of Norwegian Polar expeditions. The central feature of the exhibit is

the ship they used for these explorations, aka the Fram. You’ll find the museum on the peninsula of Bygdøy. THE VIGELAND PARK The park is a must-see in Oslo. The famous park is filled with 192 sculptures bronze and granite sculptures, far stretching lawns and long straight avenues bordered with maple trees. On a nice summer day, the park is full of people here you can go for a run, walk the dog, have a picnic or barbecue, play badminton or just do some sunbathing. HOW TO GET AROUND IN OSLO The Oslo Pass gives you free entry to more than 30 museums and attrac-

The Viking Ship Museum

tions, free travel on all public transport, free entry to outdoor swimming pools, discount on sightseeing, concert tickets, bike rental and special offers in restaurants, shops entertainment and leisure venues. You can decide whether you want a card that is valid for 24, 48 or 72 hours.

Oslo-

in numbers

Bygdøy ferry © 0399778584/Shutterstock

Foto:Johan Berge - Visitnorway.com.© Innovasjon Norge/ Universitetets kulturhistoriske museer

The Vigeland Sculpture Park

Oslo Opera House

Bygdøy beach

VISIT BYGDØY Bygdøy is a peninsula on the western side of Oslo, Norway and belongs to the borough of Frogner. Bygdøy has several museums, like the Kon-Tiki Museum, which shows all year long the legendary expeditions of Thor Heyerdahl, the Norwegian Museum of Culture History, The Viking Ship Museum and the Norwegian Maritime

• • • •

Total area: 454 square kilometres Population (2014): 634,000 Forest area: 242 km2 Park and sports arena area: 8 square kilometres • Lakes within the city limits: 343

Museum. Bygdøy is one of Norway's oldest cultural landscapes with a rich history. Bygdøy has beautiful parks and forests and some of Oslo's most popular beaches. Bygdøy is accessible by bus, bike or it can be reached by the local public ferry departing from Aker Brygge every 30 minutes.

• Islands within the city in the Oslofjord: 40 • Length of the Oslofjord: 100 kilometres

Meet the

User Groups at NDC Community By Johannes Brodwall

Oslo is a city full of enthused developers. In an average week, you can generally find two or more user groups of developers meeting somewhere in the city. In order to celebrate this, NDC has invited some of the larger user groups to share their passion with the NDC crowd. The NDC community area has 9 user groups present that will help create more action during the conference. Each user group will give quizzes, interview some of the profiled NDC speakers and conduct competitions.

The next generation of conference speakers are born in the local user groups. At NDC, we complete the loop. Meet the following user groups at this year's NDC Community:

shops. In the future we are, in addition, seeking to do more workshops and have more local speakers. Check us out at http://www.meetup.com/ DevOps-Norway/

NNUG Norwegian .NET User Group (NNUG) is an independent user group for developers by developers. We strive to be an open community where developers and architects of every level can meet up and share knowledge about the Microsoft development platform, craftsmanship and best practices for developers. We meet up about once a month, sometimes featuring international speakers, but always with great local talent ready to share and discuss both bleeding edge technology and well-established practices. We have chapters located in Oslo, Bergen, Stavanger, Haugesund, Kristiansand, Trondheim and Vestfold.

BAKSIA Baksia's mission is to promote back end development. Our presentations and speakers focus on horizontally scalable solutions and the underlying frameworks, programming languages and paradigms. We are a fast growing community of almost 600 members. In the three years since we started, 16 speakers have presented interesting topics at our meetings. We always start with food and beverages kindly provided by our sponsors; Inmeta Consulting, Conax and Ardoq. NITH facilitate our meetings with central meeting venues in down town Oslo, close to public transportation.

DEVOPS DevOps and Continuous delivery has become increasingly popular over the last few years. DevOps Norway is a meetup focusing on these topics. We are about 500 members meeting up approximately every month. So far we have mainly had internationally renowned speakers, and a few work-

BITRAF Bitraf is a hackerspace / makerspace in Oslo, which is open to anyone 7 days a week. Come by if you are interested in programming, digital art, electronics, milling and fabrication, free software, game development or other similar activities. Work own your projects in a social environment, host or attend a workshop, a game jam, hackathon, bug squashing party or a good old fashioned

LAN party. Bitraf is completely user driven, so you decide what's going on.

OSLO C++ Oslo C++ Users Group is a meetup group for Oslo-based developers interested in C++. Our main focus is C++, and C++11 in particular, but we occasionally arrange meetups about C, embedded development and other subjects that may be interesting to our members. Everyone is welcome to give a presentation at our meetups. We have had talks by both big names and local C++ers sharing their knowledge. You'll find us at meetup.com/ocppug!

STARTUP WEEKEND Startup Weekend is an intense 54 hours event which takes you trough the process of finding other designers, marketers, business people and programmers to execute on an idea during a weekend. Here you practice the act of Lean Startup, which can be applied inside both small and big companies. Some successfull funded companies we have from previous events in Oslo is http://soundrop.fm which is a jukebox spotify app with millions of people streaming, and http://swipe.to which turns presentation slides into a live experience, also with a large userbase. Check out http://oslo.startupweekend. org/ for our upcoming event at 13-15. june.

ANGULAR JS AngularJS Oslo meetup is a community of web developers dedicated to one of the most advanced and hot discussed JavaScript frameworks ideally suited for creating modern web and mobile applications. Community's mission is to help web front-end developers with selection of the best framework for their needs and to share knowledge, experience and best practices on it.

XP Extreme programming is about "turning it all the way up to 11". We see that we spend less time correcting bugs if we test earlier, so how about if we test before we have anything to test? We

OSLO ENTERPRISE SEARCH MEETUP We define enterprise search as retrieving information from certain sources and the presenting the most relevant information from these sources to target audiences. Having a good enterprise search solution is a great advantage for every company. It will become even more important as the number of data sources grows while the amount of information in each source also grows. We look at search solutions as a whole, and are interested in everything from concepts and user experience to development and technology.

of Norway's most visited web site, we cover a broad set of technologies, all related to the development and maintenance of web technology. While our group covers a variety of topics, our individual meetups are narrowed down to more specific areas of interest. We try to keep our talks centered around real-world examples and experiences. At our meetups, there is at least one talk held by people working at VG, but we also bring in great speakers from other media and non-media companies. For more information, see http://meetup. com/techshock or http://tech.vg.no

It's time to introduce your kid to coding

OSλO HASKELL Osλo Haskell is a user group for people interested in the purely functional programming language Haskell and related topics. Haskell was long considered a research language, but has seen much wider adoption the last years. Its main selling points are the extremely powerful type system, good performance and the ease of using concurrency and parallelism. We try to focus on both the concepts and theory behind Haskell and its ‘real-world’ usage in industry.

see that we avoid misunderstandings when programmers talk together, so how about if we work in pairs the whole time? We see that we get less problems if we integrate more frequently, so how about if we integrate on every check in? We see that we get better requirements if we speak more to our customers, so how about if we have a customer team member? Extreme programming is the idea that we can look at what techniques help us today and explore what would happen if we take it even further.

LÆR KIDSA KODING ‘Lær Kidsa Koding’ is a Norwegian sibling to Code.org and Code Club - a volunteer movement that seeks to introduce children to coding. We wish to increase the general IT knowledge, and contribute to IT-recruitment by giving all students a chance to learn programming. We also help schools, and provide arenas where teachers and code club instructors can meet and help each other.

TECHSHOCK TechShock is a user group for web and mobile developers, both backend and frontend. Hosted by VG, the makers

Join the Code Club Workshop at NDC! Kodeklubben teaches Norwegian kids how to code on top of 3 June, 18:30 - 20.30 at Oslo Plaza

Programming in Functional Style

The event is suitable for juniors aged 8- 18 years.

2-3 June at Oslo Plaza with Venkat Subramaniam

The aim of the workshop is to provide the attendees with enough skills to continue coding at home. Bring your kids and come. First come, ﬁrst served. Sign up at www.ndcoslo.com/codeclub

This three day course, offered by award winning author and trainer Venkat Subramaniam, will get you programming in functional programming. This course is not a theory of why this is a good idea, but a practical deep dive into the key aspects of functional programming. It will help you learn why, what, and exactly how to make use of this. Venkat is known for being a polyglot programmer and will demonstrate the functional style of programming in languages that the attendees use at their work each day.

For sign up and complete course description visit www.programutvikling.no

2 DAYS OF WORKSHOPS ON TOP OF RADISSON BLU PLAZA

DAY 1 - JUNE 2nd Tim Berglund

Jessie Shternshus

Gael Fraiteur

Fryman, Graham & Olsson

Getting Started with Apache Cassandra

Advanced PostSharp From the Horse’s Mouth

Agile Interactions Workshop

GitHub Intro + Advanced

DAY 2 - JUNE 3rd

Workshops are included in the

You may attend these workshops without going to the conference

NDC ALL ACCESS CONFERENCE PASS

NOK 18500

Alan Smith

Denise Jacobs

Kevlin Henny

Luke Wroblewski

Andrei Alexandrescu

Tristan Kromer

Windows Azure Racing Game Workshop

Raw TDD

Hacking the Creative Brain

Mobile to Multi-Device Web

25% VAT will be added

Ticket types

Price

2 Day Pre-Conference Workshop Pass 1 Day Pre-Conference Workshop Pass

NOK 9800 NOK 6800

25% VAT will be added to all ticket types.

be inspired

Scalable design and implementation using C++

Lean Startup: Your Minimum Viable Product (MVP) Sucks!

2 DAYS - JUNE 2-3rd Dominick Baier & Brock Allen

Scott Allen

Pablo Cibraro & Pedro Félix

Venkat Subramaniam

Identity and access control for modern web applications and APIs

Designing and implementing Web APIs in the .NET platform

AngularJS workshop

Programming in Functional Style

ndcoslo.com

PROGRAM – Wednesday .NET Framework Database Functional Programming Misc Languages tba Web

Room 1 09:00 - 10:00

Agile Design Gadgets Mobile Techniques

Room 2

Room 3

Architecture Devops Internet Of Things People Testing

Room 4

Room 5

C++ Front-End Framework JavaScript Programming Languages Tools

Room 6

Room 7

Room 8

PROGRAM – Thursday

Cloud Fun Microsoft Security UX

Room 9

Workshop

It’s a Write/Read (Mobile) Web

Room 1 09:00 - 10:00

10:20 - 11:20

11:20 - 11:40 11:40 - 12:40

12:40 - 13:40 13:40 - 14:40

16:20 - 17:20

17:20 - 17:40 17:40 - 18:40

Front End Design Patterns: SOLID CSS + JS for Backend Developers

Hybrid vs Native: Choosing a Mobile Strategy

Developing in a Decade

Immutability, State and Scale - Functional, Distributed Applications in Azure

C++14

John Azariah and Mahesh Krishnan

Nico Josuttis

Anthony van der Hoorn

Jeff French

Hadi Hariri

Room 5

Room 6

Room 7

Go: A Pragmatic Language

Effective Modern C++

Build a Better Bootstrap

Temporal correlation and complex event processing in JavaScript

Anthony Eden

Scott Meyers

Tim G. Thomas James Nugent

Pharo: Playing with live objects

Tudor Girba

Building End-to-End Web Apps Using TypeScript

Domain Specific Languages, the functional way

Strangling the Legacy out of an Application 10:00 - 10:20

Gil Fink

Tomas Petricek

Anders Abel

Get Unblocked Windows Azure Mobile Services from the ground up

The Agony of Lean Startup

OWIN and Katana: What the Func?

Writing RESTful web services using Node.js with a vengeance

Denise Jacobs

Tristan Kromer

Brock Allen

Jakob Mattsson

Functional Programming the Long Road to Enlightenment: a Historical and Personal Narrative

TBA

10:20 - 11:20

Niall Merrigan

11:20 - 11:40 11:40 - 12:40

Lunch Azure Web Sites Secrets, Exposed!

Error Handling Write in C++ massivelyparallel GPU code for the browser with WebGL

ReactiveUI - Turning MVVM up to 11

Seven Ineffective Coding Habits of Many Programmers

What is new: Windows Phone and Windows Store App

Web API Authorization & Access Control – done right! 12:40 - 13:40 13:40 - 14:40

Andrei Alexandrescu

Steve Sanderson

Brendan Forster

Kevlin Henney

Iris Classon

Joe Armstrong Damian Edwards and David Fowler

Dominick Baier

Move, noexcept, and push_back() and how they relate to each other

Bridging Node.js and .NET Using Edge.js

People, Process, Tools – The Essence of DevOps

CPU Caches and Why You care

Our experience from building and running a SaaS in the cloud

The Future of ASP.NET and “Katana”

Async C# 5.0 - Patters For Real World Use

Agile Team Interactions Workshop

Nico Josuttis

David Neal

Richard Campbell

Scott Meyers

Erling Wegger Linde

Scott Hanselman

Liam Westley

Jessie Shternshus

Break CQRS with Erlang

Bryan Hunter

C++ Type Functional Deduction and Reactive Why You Care Programming and Bacon

Railway Oriented Programming -- error handling in functional languages

Finally! - True Cross-Platform Federation & Single Sign-On with OpenID Connect

Leading without formal authority

How C# Saved my Marriage

Matthew Podwysocki

Scott Meyers

Scott Wlaschin

Dominick Baier

Glenn Henriksen

Scott Hanselman

Mikael Brevik

Patterns for the People

Kevlin Henney

scriptcs deep dive. Extending, customizing and embedding in your applications.

Taking Design C++ - where Patterns to are we the Next Level headed?

The mess we're in

Reginald Braithwaite

John P Mayer

Anthony van der Hoorn

Vidar Kongsli and Torstein Nicolaysen

Gael Fraiteur

Hubert Matthews

Joe Armstrong Bruce Tate

David Edwin

The Art of the Javascript Metaobject Protocol

Becoming an Outlier: Career Reboot for the Developer Mind

Docker is the future of shipping our code

Cloud beyond scaling : realtime webapplications

An Actor's Life for Me – An introduction to the TPL Dataflow Library and asynchronous programming blocks

From Knockout to AngularJS

Full Stack Web Three Cool Performance Things about D

How to scale apps and cloud services for Play Magnus

Reginald Braithwaite

Cory House

Paul Stack

Christian Holm Nielsen

Liam Westley

Yngve Bakken Nilsen

Nik Molnar

Andrei Alexandrescu

Christer V. Aas and Felipe Longe

Break

Break The journey from Powershell to Grunt for Build and Deploy

Zone out, Delivering check in, move Continuously on to 10 Million Users

Quick Tour to Front-End Unit Testing Using Jasmine

An Introduction to Nancy

.NET outside of Visual Studio

The Better Parts

Pipe dreams: Pipes |> Macros |> Beautiful Code

The C++ memory model

Paul Stack

Mark Seemann Robert Misch and Simon Hohenadl

Gil Fink

Mathew McLoughlin

Svein Arne Ackenhausen

Douglas Crockford

Bruce Tate

Mike Long

Real World Single Page Apps: A Knockout Case Study

Code that fits your brain

Making The Computer See - Computer Vision For Everyday Applications

Hacking the Internet of Things

TBA

Cross-platGitHub Power Tools form physics-based gaming using MonoGame and Farseer

Aggregation with noSQL

C++ for small devices

Cory House

Adam Tornhill

Martin Jul

Einar Otto Jack Schulze Stangvik and Erlend Oftedal

Rune Andreas Grimstad

Tim Berglund

John Zablocki

Isak Styf

Lunch

14:40 - 15:00

Break

15:00 - 16:00

Angular TypeScript

Agile Kaizen

Wherefore art thou Erlang?

Privacy for the Internet

Designing Wonderful .NET APIs

C# is in my ears and in my eyes

Node.JS Tools For Front-End Developers

TBA

Brief tour of Clang

Mark Rendle

Scott Bellware

Robert Virding

Nico Josuttis

James Newton-King

Chris Hardy

Scott Allen

Damian Edwards and David Fowler

Ismail Pazarbasi

Building Directives for AngularJS

Agile Metrics - Velocity is NOT the Goal

Discrete Math You Need to Know

Ninja vs. Samurai - Let the scripting battle begin

TBA

Insecure Free is a Lie coding in C and C++

"It doesn't work like that in enterprise"

Why no code reviews?

Scott Allen

Doc Norton

Tim Berglund

Rustam Mehmandarov and Harald Fianbakken

Greg Young

Olve Maudal

Aral Balkan

Peter Smith

Enrico Campidoglio

Facial Hair & the Road to Faster JavaScript

From Code Monkey to Boss Man

IDEs: The State of the Union

0-layered architecture

10 Things I've Learned From Doing OSS

Making sense of unstructured data

Domain The Technical modelling with Debt Trap the F# type system

So you think you can int? (C++)"

Joel Fillmore

Anthony Eden

Matt Ellis

Bjørn Einar Bjartnes

Brendan Forster

Anders Norås

Scott Wlaschin

Anders Knatten

16:00 - 16:20 16:20 - 17:20

17:20 - 17:40

Game and Simulator Physics for Developers, Gamers and Petrol Heads

Template Meta-programming in C++

Serialize All The Things with Json.NET

Alan Smith

Andrei Alexandrescu

James Newton-King

Better Software--No Matter What: The Most Important Design Guideline

Functional Code Considered Beautiful

The integrations we fear and how we can manage them

Managing Asynchronicity

Scott Meyers

Garrett Smith

Karoline Klever

Douglas Crockford

TCP servers in .NET done right

James Nugent

Single sign-on for mobile native applications

17:40 - 18:40

Workshop

The mythical beast called the Internet of Things and how to tame it

Monitoring your app with Logstash and Elasticsearch

Break

Filip W

Break

Snake Bitten: Danger and Misfortune in the Evolution of Programming Languages

Room 9

Beyond NuGet: Front End Package Management with Bower

Break Scaling Event Processing at all scales and all languages with the Reactive Extensions

Room 8

Delightful WebGL in Elm, with FRP and Types

Break

15:00 - 16:00

16:00 - 16:20

Room 4

Break

Nik Molnar

14:40 - 15:00

Room 3

Javascript Combinators

Luke Wroblewski 10:00 - 10:20

Room 2

Break

Doc Norton

Pedro Félix

PROGRAM – Friday

TIMESLOTS 09:00 - 10:00

Room 1

Room 3

Room 4

Room 5

Room 6

Room 7

Room 8 Getting Agile with Scrum

Room 9

Coding against MongoDB in .NET

Metamagical programming with expression trees

F# and Machine Learning: a winning combination

Some Time Later: What’s the state of HTML5 & hybrid apps?

Continuous Delivery with Octopus Deploy

Build an extraordinary career by sharing your knowledge

Functional Programming: What? Why? When?

Craig Wilson

Einar W. Høst

Mathias Brandewinder

Kevin Boyle

Jeff French

Johannes Brodwall

Robert C. Mar- Mike Cohn tin

Vagif Abilov

Beautiful Builds

Break

10:20 - 11:20

Data Modeling The Future of Examples in Extreme Web the Real World Browsing with MongoDB

1) Write cross-platform apps with F# & Xamarin. 2) ??? 3) Profit!

Help! My code Accelerating quality is not Windows manageable Store app development by using Prism for the Windows Runtime

Internet of Things - Controlling the world with Arduino and JavaScript?

Advanced TDD: The Transformation Priority Premise

Craig Wilson

Rachel Reese

David Britch

Patroklos Papapetrou

Magnus Green

Robert C. Mar- Mike Cohn tin

Roy Osherove

Robby Ingebretsen

User Stories for Agile Requirements

Workshop

Typed? Dynamic? Both! Cross-platform DSLs in C#

10:00 - 10:20

11:20 - 11:40

Break

11:40 - 12:40

Back to basics: Making 3D Finalization games with and MonoGame disposition in .NET

Lessons Learned - Web Application Testing in .NET

A lap around the Windows Phone 8.1 development platform

Architecting large Single Page Applications with Knockout.js

From SQL to RavenDB: A .NET Team’s Journey

Transforming your C# code to functional style

Agile Estimating

Say Hello to your Google Android Wear Watch

Nicole Calinoiu

Richard Garside

Gáspár Nagy

Andy Wigley

Steve Sanderson

David Simner

Venkat Subramaniam

Mike Cohn

Wei-Meng Lee

Advanced Top- HTML5 & ics in Agile JavaScript Planning Communication APIs

JOBB I BEKK ? Vi tror at interesser og lidenskap er viktig – både på og utenfor jobb. Nysgjerrige mennesker oppnår rett og slett mer. I BEKK får du mulighet til å utvikle deg videre, både som menneske og fagperson.

12:40 - 13:40

Lunch

13:40 - 14:40

Hadoop Kickstarter for the Microsoft Platform

How I hacked my way to Norway

Porting Quake III to F#: A Journey to Functional Programming

Building Universal Apps for Windows Phone and Windows 8.1

.NET Rocks Live!

The Internet Of Things and everything wireless

Clean Architecture and Design

Gary Short

Troy Hunt

Will Smith

Andy Wigley

Richard Campbell

Jarle Boe

Robert C. Mar- Mike Cohn tin

Christian Wenz

Sirar Salih

Introducing Roslyn

Making Actors Programming Scalable Pebble

TDD in Tatters From text to full-text

Towards an Evolutionary Architecture

Leading a Self-Organizing Team

A Heaping Stack of Scripts: Getting the most out of JavaScript Stacktraces.

TDD with AngularJS and TypeScript Workshop Part II

Justin Rusbatch

Natalia Chechina

Scott Bellware

Martijn Laarman

Venkat Subramaniam

Mike Cohn

Todd Gardner

Sirar Salih

Web Audio: Can you hear me now?

The Future of Windows 8.1 UX with Kinect Store Apps for Windows – Given to Fly v2

A Peek into an Enterprise Development Operation Team

A reality check on the Internet of Things - and how you can get started with your own project

Core Software Design Principles

History of Programming: Part 1

Case study: Making use of functional programming techniques in ..NET

Simen Sommerfeldt

Venkat Subramaniam

14:40 - 15:00

TDD with AngularJS and TypeScript Workshop Part I

Break

15:00 - 16:00

16:00 - 16:20

Break

16:20 - 17:20

Using the Scrum Rules Against your Boss

Anders Abel

Room 2

Jory K. Prum

Carl Franklin

Wei-Meng Lee

Kevin Dockx

Nils Kjetil Vestmoen Nilsen

Mark Rendle

Hans-Christian Holm

Sjekk ut ulike jobbmuligheter og hele vår faglige bredde på våre nettsider. www.bekk.no

gs Warnin

tion onfirma

Voting

d Passwor

Passwo

g Verifyin

Survey

SMS Billing

ing

Market

ers

Remind

Loyalty

Club

Voting

Contact LOVE update SMS

HLR

SMS API

ing

Donatio

Position

Mobile ng marketi Returadresse: ProgramUtvikling AS. Postboks 1, 1330 Fornebu Merge SMS

Orderin

The fast way to integrate

SMS into your software

C# Java HTTP ASP COM SMPP MSSQL YAP SMTP FTP Web Services

n Donatio

HLR

sales@vianett.no l

Voting

onfi

SMS Billing

g Verifyin

Rabekkgata 9, Moss - Norway

rmation

ww.vi

unt: w per acco

develo

m20inde +47 69 R 20e 69

rd Passwo

For more information:

www.vianett.com arketing

eloper

m/dev anett.co

Survey

ing

Booking

ord

free

Erik Lerbæk IT-manager, Viking Redningstjeneste AS

Position

Sign

for a up now

“ViaNett`s API`s are simple and easy to understand, well documented and their support is excellent”

Paymen

MMS

ired Get insp

Voting

Order Ask

Merge SMS

We love SMS!