Ndc magazine 3 2014 by NDC- The Developer

NO 3/2014

www.ndcmagazine.com

MAGAZINE FOR SOFTWARE DEVELOPERS AND LEADERS

THE DEVELOPER

SENSORS, THE INTERNET AND YOUR EVERYDAY COMMUTE

DON’T IGNORE AZURE STORAGE SERVICES MARK RENDLE

KRISTOFFER DYRKORN

CREATE YOUR VERY OWN IOT DEVICES

STATUS FIELDS ON ENTITIES – HARMFUL?

SUZ HINTON

UDI DAHAN

NDC LONDON Conference, 3.-5. Dec Pre-workshops, 1.-2. Dec

Creativity and Innovation:

CRITICAL TOOLS FOR SUSTAINED SUCCESS DENISE JACOBS

O ND

L DC

U ISS

THE DEVELOPER

3-2014

NDC Magazine for software developers and leaders

From Crisis to Success I think it’s a fantastic time to be working in the software industry. We now truly have multiple platforms and delivery mechanisms from cross platform desktop apps, highly functional web sites, mobile applications, wearables, and devices with no UI coming with the Internet of Things. For developers we have functional languages, great client side frameworks, cross platform mobile tools and the server side ecosystem is being enriched with open source and Microsoft rebooting with ASP.NET vNext supporting cross platform execution for more effective cloud deployment. Now that (some) developers have finally admitted their fallibility we have placed testing into the development process as a first class citizen. Now, we need to convert that continuous integration into continuous delivery and deployment too. In addition it’s time to see whether the original promise of Agile and XP is actually being fulfilled, and how we can

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

improve the process of creating software. As our lives become more entwined with devices and software, we bear a great responsibility of getting things right and delivering software that is usable, flexible and reliable. With this abundance of topics, creating a conference agenda that is fully inclusive is a formidable task, but I think we’ve managed to make NDC London provide a fantastic snapshot of where software development is heading in 2015. LIAM WESTLEY Application Architect at Huddle

Advertise in the NDC Magazine and meet your target group! For more information about advertisement, please contact Charlotte Lyng at +47 93 41 03 57 or charlotte@programutvikling.no

NIALL MERRIGAN

NDC-Magazine_2-2014-NEW.indd 1

09.05.14 11:09

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

Contents ARTICLES Sensors, the Internet and your everyday commute

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

p. 4

Using the Arduino platform tocreate your very own IoT devices .............................................................................................................. p. 8 Status fields on entities –HARMFUL? ........................................ p. 12 Don’t Ignore Azure Storage Services ........................................... p. 20 Unlock the value of your data with ElasticSearch ....... p. 24 Architecture for CD ............................................................................................. p. 30 Creativity and Innovation: Critical tools for sustained success

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

Thinking like an Erlanger – Part 1

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

p. 34 p. 38

Create a custom agile process for your organization .................................................................................................................... p. 44 Exceptional naming Course descriptions

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

p. 48

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

p. 50

NDC LONDON 2014 Tickets ................................................................................................................................. p. 55 The NDC Agenda Committee .................................................................. p. 56 Workshops ........................................................................................................................ p. 58 London .................................................................................................................................. p. 60 Entertainment and food

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

p. 62

Program Wednesday - Friday ................................................................... p. 64

Editor: Kjersti Sandberg

Marketing Manager: Charlotte Lyng

Member of Den Norske Fagpresses Forening

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

Sensors,

the Internet and your everyday commute 4

The Norwegian Public Roads Administration is building a new infrastructure for road traffic measurements. Besides classical project goals like improved data quality and lower maintenance costs, you and me will also benefit: the system will make it possible to pinpoint where and when congestion normally occurs in the rush hours and on special holidays. So in the future, you might look at both weather and traffic forecasts when planning your Easter holidays in the mountains! By Kristoffer Dyrkorn

I sometimes hear that Norwegians tend to do the same things at the same time. We are a little bit like herd animals since we go to work at around the same time, deliver kids to school or kindergarten at the same time and drive to our cottages on Friday afternoons and back on Sunday evenings. Since the roads are not built for our habitual behaviour, we get stuck in traffic - especially in our more densely populated areas.

ÂŠ hobbit /Shutterstock

It must also be said that road construction and maintenance is a challenging task in Norway. Due to the topography and the harsh climate the costs associated with building and keeping roads at high standards are substantial. In addition, planned or unplanned maintenance will often lead to congestion - and setting up detours is sometimes impossible since our road network is sparse. Still, proper maintenance is vital for cost-effective operation. The new traffic measurement system will be beneficial for both us and the road administrators. It will produce more detailed data about traffic patterns - data that will be publicly available for us to download and build applications upon. The same type of information will be used for creating detailed maintenance plans or improving road safety. Traffic volumes and vehicle weights are two of the main factors that decide wear and tear on road surfaces. The climate, and especially seasonal phenomena like frost heaving, also contribute.

ÂŠ hobbit /Shutterstock

The system consists of roadside sensors, embedded devices for vehicle registration and classification, a data gathering network and a server side application for analysis, storage and reporting. The information that is gathered should be harmless from a privacy point of view. The sensors utilise induction and pressure sensitivity. They are built into the road pavement and do not register any identifying information about the passing vehicle, owner or driver. Only the fact that a vehicle has passed, and its speed and weight, is logged. The model, colour or registration number cannot be detected by the sensors. A registration and classification device converts the magnetic signature of a vehicle into a record containing a time stamp and the measured vehicle length, weight and speed. The record is then transmitted over a standard Internet connection using OPC-UA, a protocol stemming from the automation and process control industry. The data is encoded in a compressed binary format while the protocol itself guarantees reliability, security and integrity - at the same time being platform independent and resource efficient. The record is received by a Java application that does simple near-time analysis. As an example, it is important to immediately detect and flag any vehicle that is driving in the wrong direction on a motorway. Such a situation is extremely dangerous and nearby drivers should be informed through any channels available. The detection of these socalled "ghost drivers" is based on the registration of negative speeds. On two-lane roads, however, a negative speed might come from a car passing another car - which is a normal event. The application thus contains logic to separate these two situations from each other. The record is then stored in a database. Here NoSQL technology provides the needed support for high-speed writes, large data volumes, robustness and quick and efficient reporting. The system stores all records explicitly to secure full flexibility in the report creation, both for current and historical data. Currently, the system is in its start-up phase. The software has all the needed basic functionality for data-gathering and

reporting. A large batch of roadside sensors is now being acquired and will be installed along the main roads in Norway in the next couple of months. After that, the system will be enhanced with new functionality and adaptations for larger traffic volumes as more and more sensors get installed. One of the main goals of the system is to improve road traffic statistics for better maintenance planning and investment control. However, it is also a clear goal that the system should provide open and near real-time traffic data to the public and to public and private institutions. There are several use cases that illustrate the value of such data: police or ambulance drivers in an emergency can get driving recommendations that consider the current traffic situation. Ordinary drivers can be advised about congestions ahead and be offered alternative routes. Also, parcel service companies can provide more precise estimates on expected arrival times to their customers. The potential value of this system thus spans efficient public spending, nice-to-have information for technology and/ or driving nerds and time savings of potentially life-saving character. We will need to wait some time to see how the system will be used and whether its full potential will be reached. One thing is clear: all of this is made possible just by using software, sensors, the Internet and hardware that is connected!

Kristoffer is a Scientist at BEKK. He has been a developer, team lead or solution architect the latest 15 years and has broad experience from a variety of fields such as search engines, performance tuning, NoSQL for analytics and 3D graphics. At the moment he is mostly working on systems architectures for distributed stream processing.

One day of Internet of Things

6. November Radisson Blu Scandinavia Oslo

internetofthingsday.com

CONNECTING PEOPLE AND THINGS - BRIDING BUSINESS AND TECHNOLOGY The term Internet of Things and its possibilities have been discussed for a decade, however we seem to be at a point of rapid acceleration of the field. In 2008 the number of devices on the internet exceeded the number of people on the earth. By 2020 it is estimated that there will be 50 billion devices on the internet. TIME

BUSINESS & APPLICATIONS

TECHNICAL I

TECHNICAL II

08:00 - 09:00

Registration – Coffee and snacks

09:00 - 10:00

Keynote: Internet of Things – a driver for innovation and growth - John Baekelmans (Business & Applications track)

BREAK 10:15 - 10:45 10:45 - 11:15

Enabling Business transformation by predictive analytics, a case study ThyssenKrupp Elevators - John Hicklin

Internet of Things – Hyper-Scale Control and Analytics Systems on Microsoft Azure (and Windows Server) - Clemens Vasters

Bluetooth Smart, the standard that will fuel the IoT growth - Reidar Martin Svendsen

IoT & The People-Centric Approach: Transforming lives in a meaningful way Anna Kirah

A fragile internet of things Einar Otto Stangvik & Erlend Oftedal

Elixir and the Internet of Things Douglas T. Rohrer

The anatomy and technology of connected products - Nick Ludlam

Beating the traffic jam using IoT Kristoffer Dyrkorn & Erling Berg-Tesdal

Is it possible to secure micro-controllers used within IoT? - Aaron Ardiri

BREAK 11:30 - 12:00 12:00 - 12:30

Audio Design and Branding for the Internet of Everything - Tom Trones

LUNCH BREAK 13:30 - 14:00 14:00 - 14:30

How a simple IoT solution is driving sales and empowering the customer - Stephen Harrison Supercharge your IoT toolbox with MQTT and Node-RED - Simen Sommerfeldt

BREAK 14:45 - 15:15

Using IoT in health care - Johan Ivarson

15:15 - 15:45

An early road-map to making the right Internet of Things investment - Thor Henning Hetland

New Bits, New Pieces: Inspiration for building IoT for everyday use - Aras Bilgen

Electric driving with front end technology Trygve Lie Internet of Machine Learning Kristoffer Rolf Deinoff

BREAK 16:00 - 16:45

Real-Time Data From One Million Sensors Steinar Rune Eriksen & Ståle Heitmann

RealTime communication and IoT walks hand in hand - Uffe Björklund

BREAK 17:00 - 17:30 17:30 - late

Closing Keynote by Steve Teixeira Evening mingle with drinks and tapas

JavaScript army – making things walk, talk, and network to do your bidding - Suz Hinton

Using the Arduino platform to

create your very own IoT devices By Suz Hinton

ÂŠ Vudhikrai/Shutterstock

As a software developer, there's something magic about being able to say, "I made this myself!". Building hardware to integrate with software is no different. Sure, you can buy off the shelf IoT devices for your home and lifestyle, but there's much more fun in building your own. You'll learn a lot about how they work, and will take away a sense of pride and achievement. MODULAR JAVASCRIPT This is just a quick project showing how simple it is to get up and running with building and programming your own Internet of Things devices. When all assembled and placed in a mailbox, this contraption will connect via WiFi to both email and SMS you when you get mail! In this example, I'm using an Arduino microprocessor teamed with a light sensor and a WiFi module. A battery

powers the Arduino, which constantly keeps track of how much light is in the mailbox. When the postal delivery opens the little back door to put your mail and parcels in, light streams into the mailbox. This trips the device, which will then connect to WiFi and send the email and SMS to you. If you do not have one of those door opening mailboxes, you can program it the opposite way - put it in your mailbox so that the sensor gathers light from the mail slot, and when envelopes are pushed through it blocks the light momentarily. Effectively that will be the trigger.

This only works in daylight, but it's pretty cool anyway. Your mileage may vary with WiFi strength if your mailbox is made of metal. The full code is hosted on Github: https://github.com/noopkat/tinyduino-wifi-helloworld

**Warning** - postal companies might not be too pleased about spotting a mysterious device in a mailbox. They won't always assume it's a perfectly harmless Internet of Things device. I am not condoning breaking the law with this project. Make sure you're familiar with mail/mailbox tampering laws in your country. Long story short - don't scare your friendly neighbourhood post deliverer. Nobody wants the police outside their house!

ASSEMBLY My favourite feature of the TinyCircuits system (other than the tiny size) is the way they easily click together to supply the technology you need. First, we're going to click everything together as we need it. Take the processor board, and click the USB module to the top of it. Then, click the WiFi module to the top of the USB one. Lastly, click together the proto board to the very top of the stack. This will be the order of the stack when we develop it. It allows us to power the board without a battery via the computer, and we can also program it this way. Next, remove the proto module from the top of the stack. Solder the resistor and photocell to it. The resistor goes from A0 to GND, and the photocell shares the A0, and the

Parts needed

SHOPPING LIST • TinyCircuits Processor board • TinyCircuits WiFi module • TinyCurcuits Proto module (any will do) • TinyCircuits USB programmer module (not pictured) • Micro USB cable • 10k Ohm resistor • Photocell resistor • 3.7v LiPo battery, at least 500mA Tools I assume you have already: • LiPo charger • Soldering iron • Solder

other end goes to VBATT. VBATT is a special pin that makes both the USB and battery power sources available to use. See the photo on the next page for how it will look when complete. Note I have left the component arms rather long so that it's easier to see what's going on. UPLOAD ARDUINO CODE Click the proto module back onto your TinyCircuit stack. Plug a micro USB cable into the programming board, then connect to your computer. In the Arduino software, set the board to 'Arduino Pro Mini 3.3v w/ ATMega 328'. Open the sketch from the repo and click 'upload'. Select the correct USB device if prompted.

Final assembly

The main loop of the sketch is pretty simple, see the truncated code below: uint32_t ip = cc3000.IP2U32(10,0,1,4); int port = 8081; String path = "/mailbox/token/"; String token = "558822"; String request = "GET " + path + token + " HTTP/1.0"; void loop(void) { sensorValue = analogRead(sensorPin); // print to serial monitor for debugging purposes Serial.println(sensorValue); // if light source appears, set bright to true and send request // you may have the fiddle with this value to suit your light source if (sensorValue < 450 && bright == false) { // this will ensure request is sent only once bright = true; // send request to mailbox server send_request(request); } // light source gone, go back to dark mode again if (sensorValue > 450 && bright == true) { bright = false; }

}

delay(300);

You'll definitely need to play with the default light reading value set in the code above for best results with the physical place you're setting up your device in.

SET UP YOUR SERVER I created a really simple NodeJS hapi server instance for dealing with the email and SMS. It is running on the local network the device is connected to via WiFi. The server simply waits for a GET request to the specified route, then verifies the request with a static token the Arduino will send as part of the request. This token should help stop your friends pranking you! When the request is successful, the route handler will call some third party API's to send the notifications. I'm using Twilio for SMS, and Mailgun for the email. A truncated sample of the code: var Hapi = require('hapi'); var server = new Hapi.Server('10.0.1.4', 8081); var passToken = '558822'; server.route({ method: 'GET', path: '/mailbox/token/{token?}', handler: function (request, reply) { if (request.params.token && request.params.token === passToken) { // Twilio sendSMS(); // MailGun sendEmail(); // simple reply for testing manually reply('you\'ve got mail!'); } else { // someone's being a prankster if missing/wrong token reply('why you gotta troll me, friend :('); } } }); // Start the server server.start();

Start the server in bash: node index.js

TEST YOUR DEVICE While still plugged in to your computer, reset your device, and make sure your NodeJS server is running. To debug, watch both the Arduino app serial monitor's output, and your bash window. Play with the photo sensor, covering it up and then exposing it to light. You should start receiving emails and SMS's. Once verified, you can take the USB programming module out of your TinyCircuit stack completely, as we no longer need it. You'll see 2 terminals on the processor board. Solder a LiPo battery JST connector to these terminals in order to have this device run truly wire free and discreetly. Test again with the LiPo battery connected, then you're ready to use your finished device! OPTIONAL STEP 3D print a case for your new contraption, to make it look geek professional.

Suz Hinton is a software engineer by day, and maker by night. Having developed several delightful devices over the years with the help of microcontrollers, Suz is a big supporter of the recent IoT movement. Her interests within the IoT sphere are on a data ownership and educational level. She believes that empowering people to utilize the latest technology and manufacturing techniques will see a high level of innovation and an increase in access to the field of wearables, home automation, and medical assistive devices.

Status fields on entities – HARMFUL? By Udi Dahan

It all started so innocently – just a little status field on an entity. Now, there’s no way to know whether it was truly the root cause of all the pain that came afterwards, but there does seem to be some suspicious correlation with what came next.

Today, our batch jobs periodically poll the database looking for entities with status fields of various values and, when they do, the performance of the front-end takes a hit (though the caching did help with the queries). Once upon a time it used to be manageable, but with over 50 batch jobs now the system just can’t get its head back above water.

Even in the cases where we used regular asynchronous invocations, the solution wasn’t particularly solid – it was enough for a server to restart and any work not completed by those tasks would be rolled back, and any memory of the fact that we really need that task to be done gone along with it.

And don’t get me started on the maintainability or, more accurately, the lack of it. Every time someone on the team made changes to some front-end code, they invariably forgot at least one batch job that should have been changed as well. And since some of these jobs can run hours and days later, we didn’t really know that the system worked properly when we

deployed it. And don’t bring up that automated testing thing again – we’ve got tests, but if the developer was going to forget to change the code of the batch job, don’t you think they’d forget to change its tests too? If only I could say “never again”, but this is the third system rewrite that I’ve seen go bad in my career. And the alternative of continuing to battle an aging code base that gets ever more monolithic isn’t any more appealing. It’s like we’re doomed. DID ANY OF THAT SOUND FAMILIAR? If so, you might be able to take some comfort in the fact that you’re not alone. Misery does love company, after all. In any case, let’s rewind the story back a bit and look at some of the inflection points. As time goes by, the logic of many systems gets more and more complex – starting slowly with some status fields which influence when logic should be triggered. Together with that complexity, the execution time of the logic grows often making it difficult to for the system to keep up with the incoming load. It’s at that point in time that developers turn to asynchronous technologies to offload some of that processing. THE PROBLEM WITH ASYNC/ AWAIT When you have some work that can take a long time, it is often appropriate to invoke it asynchronously so that the calling thread isn’t blocked. This is most significant in web frontend scenarios where the threads need to be available to service incoming HTTP requests. Of course, as often is the case with web requests, we do want to give the user some feedback when the processing completes. This can be done by marshalling the response from the background thread to the original web thread – something that has been greatly simplified with the async/ await keywords in .net version 4.5.

The issue is, as mentioned above, that there is no built-in reliability around these in-memory threaded constructs. If an appdomain is recycled, a web server crashes, or any number of other glitches occur – not only is the work done on the async thread lost (if it didn’t complete), but the managing thread that knew what needed to happen next is also gone, in essence leaving our process in a kind of limbo. Interestingly enough, sometimes batch jobs are created as a kind of clean-up mechanism to fix these kinds of problems. Also, since batch jobs frequently operate with database rows as their input as well as their output, it is believed that many of the reliability concerns of in-memory threading are resolved. But we’ll get to that in a bit. First, let’s talk about how the introduction of these batch jobs influences our core business logic: THE IMPACT OF BATCH JOBS ON BUSINESS LOGIC While developers and business stakeholders do understand that introducing these batch jobs into the solution will increase the overall time that it takes for a business process to complete, it is considered a necessary evil that must be endured so that the front-end can scale. Unfortunately, what is often overlooked is the fact that the business logic that used to be highly cohesive has now been fragmented as shown in Figure 1.

Now, if the logic was merely divided into two parts things might have remained manageable, but often the logic in the batch job is rewritten as stored procedures1 in the database or using other Extract-TransformLoad2 (ETL) tools like SQL Server Integration Services3 in an attempt to improve its performance. This is sometimes exacerbated by the fact that a different team, one focused on those other technologies, ends up maintaining that batch job. And while a single batch job is likely not considered to be all that “evil”, it does seem that when a second batch job comes along they start to reproduce. And their devilish spawn is what ultimately brings our system to its knees with logic scattered all over the place. And, although each decision taken seemed to make sense at the time, it seems that this road to hell was also paved with plenty of good intentions. THE NOT-SO-NIGHTLY BATCH It was not so long ago that business was conducted from 9 to 5 in a specific time zone. You could assume that your users wouldn’t need to access various systems during “off hours”. But it’s a very different world these days – a more connected and more global world. Systems that used to be accessed only by employees of the company have been opened up for end-user access and these end users want to be able to do anything

Figure 1. Introducing a batch job into a system results in the fragmentation of business logic

and everything on their own schedule, 24x7. In an attempt to keep pace with end-user demand, employees have similarly transitioned to an “always on” mode of work, on top of increasing travel demands. In short, that once luxurious night in which we could run our batch jobs uninterrupted has shrunken so much over the past 20 years that it’s practically nonexistent anymore. THE PERFORMANCE IMPACT The whole idea of moving logic into a nightly batch was so that it wouldn’t impact the performance of the system while the users were connected but it seems that this has boomeranged on us. Anybody who tries to use the system at a time when a batch is running gets significantly worse performance than if we had kept the original logic running in “real time” as at that time the batch is processing all records rather than just the ones that the user cares about.

On top of that, the fact that a batch job runs only periodically increases the end-to-end time of the business process by that period. Meaning that if you have a nightly batch, it could be that a given business process that started right as the nightly batch completed would have to wait almost 24 hours to complete. If there are additional batch jobs that pick up where other jobs left off as a part of an even larger enterprise process, that sequence of batch jobs can cause these processes to drag on over a period of days or weeks. And if we start looking at how failures are dealt with, the picture begins to look even more bleak. DEALING WITH FAILURE If any job actually fails as that can add even further delays. This failure could be caused by some other transaction processing the same record at the same time – a concurrency conflict. To

be absolutely clear, what this means is that the records which are the most active are the most likely to fail. Unfortunately, there is no built-in way to have the processing retry automatically so developers usually don’t remember (or put in the effort) to create one. “It’ll just be picked up in the next cycle”, they tell themselves. However it may be just as likely that a conflict will happen on the next cycle as it did in the last one. Every time something fails, that’s another delay in the business process. RISKS AROUND PERFORMANCE OPTIMIZATIONS Sometimes developers attempt to optimize the performance of the batch jobs in an attempt to get them to keep pace with the ever increasing number of records in the system. One of the techniques that’s used is to operate on multiple records within the same transaction rather than doing one transaction per record.

While this does tend to improve performance, it has the unfortunate side effect of increasing the impact of transaction rollbacks when failures occur. Instead of just one record reverting to its previous state, all the records in that transaction get reverted. This increases the business impact as more instances of the business process get delayed. Also, as mentioned above, since the most active records are the ones most likely to fail, and the activity levels of various records fluctuate over time, it is quite possible that a given set of records will end up failing repeatedly as conflicts occur for different records within the same set. In short, while more records can be theoretically processed per unit time when performing multi-record transactions, it may very well be the case that the rate of successful record processing actually decreases. So, how do we resolve all of these issues? USE A QUEUE AND MESSAGING (PART 1) When developers hear the term “queue” they usually think of technologies like MSMQ, RabbitMQ, or something else that ends in the letter MQ (meaning message queue). While those are viable approaches, it is important to understand the architectural implications of a queue first. A queue is a “first-in, first-out” (FIFO) data structure that enables different actors to interact in a decoupled manner. The important thing about the “messages” that are pushed into and popped out of the queue is that they are immutable – meaning their values don’t change. HOW QUEUES & MESSAGING ARE DIFFERENT FROM DATABASES While it is common to have different actors reading and writing from tables in a database, the difference is that the entities in those tables are modified by those actors – meaning that they are not immutable. In this

sense, traditional batch operations aren’t really using queuing or messaging patterns for their asynchronous communication. While it is perfectly feasible to implement a queue on top of a regular table in a database, it is important that the code that reads and writes from that table treats its contents as immutable messages – not as a master data entity. For this reason, it is usually desirable to abstract the underlying technological implementation of the queue from the application-level code – something like an IQueue interface with Push and Pop methods that have copy-semantics on the message objects flowing through the queue. QUEUE VS. DATABASE – CONSIDERATIONS The advantage of using a databasebacked implementation of an abstract queue is that all data continues to flow through the exact same persistence mechanism resulting in simpler deployment, high availability, backup, and restore. The disadvantage of using the database is that, depending on your database technology, it may be more expensive to scale the database to meet increasing performance needs than a message queue. That being said, just like there are numerous free and open-source message queues, there are also numerous free and open-source databases. The main advantage of using mes-

sage queuing technology is that it was designed specifically to address these kinds of problems. You’ll usually find that queues are able to achieve higher throughput as well as give you better control around how messages should be delivered and processed. For example, you may have certain kinds of messages which represent data arriving from sensors at a high rate that don’t actually have to be persistent as you don’t care if they get dropped in case of a server crash. A message queue enables you to define these messages as non-durable and thus achieve much better performance. The main disadvantage to introducing message queueing technology is that it is another moving part in your system – something that administrators will need to learn how to configure, deploy, etc. That has its own cost (if the administrators aren’t already familiar with it). LEAKY ABSTRACTIONS While you might think that having this abstraction will practically insulate your system from the underlying technological implementation, it is important to understand that once the system is live there will be many messages flowing through it on an ongoing basis. In order to switch from one implementation of a queue to another (to/from a queue to/from a database), it isn’t just a simple matter of changing the class that implements the interface. You may need to “drain” the system – meaning having it refuse any new requests until it finishes processing all

the existing messages. This can mean significant downtime for a system. Alternatively, you could write scripts which move all of the messages currently in-flight from one persistent store to the other. Like all data migrations, this can be tricky and should be tried and tested in pre-production environments sufficiently well before attempting it in production. USE A QUEUE AND MESSAGING (PART 2) If you start writing your application code using this kind of IQueue interface, adopting a more explicit message-passing communication pattern in your system, is that many of the problems mentioned above will be much easier to solve – let’s see why. Once you use an explicit message object to pass data between actors (rather than having them polling entities of various statuses and updating those exact same entities), you reduce the contention on your master data entities. The message object communicates the important status changes and can serve as a more formal contract between those actors. Just like any other interface in your system, a message contract should

be versioned carefully, taking into account which consumers could be affected. PROCESS STATE VS. MASTER DATA Entities with status fields often end up doing double-duty as both master data as well as holding the state of some longer-running business process. This probably isn’t the best idea, as stated by the tried-and-true Single Responsibility Principle4. If you have an entity with a status field where that status changes values over time, that is usually an indication that you should create a separate processcentric entity that holds data related to the process that isn’t necessarily master data. While it can sometimes be tricky to draw the line between the two, it is a worthwhile exercise. Don’t be influenced by the need to show the state of the process to the user – you can just as easily create a UI on top of a persistent process entity as you could on top of a regular business entity. That being said, sometimes you can model these processes as a kind of event cascade as shown in Figure 2 and Figure 3.

Figure 2. Batch processing moving forwards a business process

Often in a system, a combination of approaches is used with some eventdriven, publish/subscribe interaction and some process objects where we require more control and visibility of progress. THE PERFORMANCE IMPACT Regardless of whether you use an actual message queuing technology or a database, once you make your messages immutable, you will have removed some of the contention on the entities (as they won’t be serving double duty as both a message and an entity anymore). When taken together with building blocks with their own database schema, the rest of the contention is removed thus enabling us to perform the processing in “real time” rather than as a batch. This combination can reduce business process times from days and weeks when performed as a series of batch jobs to minutes and seconds. DEALING WITH FAILURE The second significant benefit of message driven solutions is that many queues already have retry semantics built in so that even in the case of message processing failure, not only do things roll back but they get processed again automatically (and in the same real-time as before). Queuing technology usually has additional capabilities in this area including the ability to move “problematic” messages off to the side (into a “poison letter queue”) so as to free up the processing of other messages. You can usually configure the policy around how many times a message needs to fail before it is flagged as a “poison message”. TRANSITIONING FROM BATCH TO QUEUES The good news is that if you’re already making use of batch jobs, a lot of your code is already running asynchronously from previous steps – this makes introducing a queue much easier than if you had everything running in one big long process in your front end.

Figure 3. Cascading events using a queue as a business process

One challenge you may have, if a lot of the batch job logic was (re)written as stored procedures in the database, will be rewriting that logic back in your original programming language. You’ll usually get better testability along the way, but this can take some time. It is best to start your transition from the last batch job in the sequence and slowly work your way forwards. That way, you’re not destabilizing critical parts in the business process where it isn’t clear what other jobs are depending on them. When opportunities present themselves for building new functionality, or extending an existing business process, look to create new events that you can publish and have a new subscriber run the logic for those events using these new patterns. Hopefully, this will allow you to demonstrate the shorter time to market that this approach enables.

IN SUMMARY Every time you see yourself creating a status field on a given entity, keep your eyes peeled for some batch job that will be created to poll based on that status. It would be better to create an explicit event that models what happened to the entity and have a subscriber listening for that specific case. If your system is built using .NET and you’d like to use a framework that abstracts away the queuing system as well as enabling you to run on top of regular database tables for simpler deployment, take a look at NServiceBus. All of that functionality is available out of the box as well as giving you the ability to extend it for your own needs. Production monitoring and debugging tools are also available for NServiceBus as a part of the Particular Service Platform. For more information, go to http://www.particular.net

REFERENCES 1) http://en.wikipedia.org/wiki/ Stored_procedure 2) http://en.wikipedia.org/wiki/ Extract,_transform,_load 3) http://en.wikipedia.org/wiki/SQL_ Server_Integration_Services 4) http://en.wikipedia.org/wiki/ Single_responsibility_principle

Udi Dahan is one of the world’s foremost experts on Service-Oriented Architecture and DomainDriven Design and also the creator of NServiceBus, the most popular service bus for .NET.

Database Lifecycle Management

Your SQL Servers get source control, continuous integration, automated deployment, and real time monitoring. You get fast feedback, safe releases, rapid development, and peace of mind. Find out how at www.red-gate.com

@redgate

/RedGateSoftwareTools

/RedGateVideos

Donâ&#x20AC;&#x2122;t Ignore Azure Storage Services

ÂŠ Everything_possible/Shutterstock

By Mark Rendle

Azure

Microsoft’s Azure cloud platform has come a very long way since the first public preview just five years ago. Back then, the only option for running applications was Cloud Services, which were hard to work with and could take half an hour to start. And the only option for data storage was Azure Storage Services, offering Blobs for unstructured data, Tables for structured data, and Queues for durable messaging. These days things are very different. There are multiple ways to run your code (or other people’s), from Infrastructure-as-a-Service (IaaS) VMs, running Windows or Linux, to high-density Platform-as-a-Service (PaaS) Azure Web Sites. And for data storage, you’re spoiled for choice. For relational databases, Azure SQL Database is a good, solid service; ClearDB provide managed MySQL; you can run full SQL Server, or Oracle, or whatever database you like (hint: PostgreSQL) in an IaaS VM. You can get managed NoSQL solutions like RavenDB, MongoDB or Microsoft’s just-launched DocumentDB. Fast, non-persistent caching is now available with the Redis Cache Service. Messaging can be handled using Service Bus or Redis. With this smörgåsbord of services available, then, it’s easy to forget about the original Storage Services, but that would be a mistake. They were designed to provide massively scalable and cost-effective solutions, and they still do that today. In fact, they’re more cost-effective than ever, with per-gigabyte storage and bandwidth and per-transaction prices regularly being cut. So let’s take a fresh look at these services, and talk about what you should use them for to increase performance and save money. BLOB STORAGE This is the old faithful, the service that everybody uses, even if they don’t know it. You can put any file in Blob Storage and it’s stored in at least three

places; more if you have the Zone- or Geo-Redundancy switched on. If you’re running any kind of VM, the underlying virtual disk (VHD) file is a page blob. But a lot of people, particularly those who have migrated an existing system to Azure, still keep massive lumps of binary data in their SQL database. Don’t do this. For one thing, it’s really expensive; for another, if you do it with Azure SQL Database, you’re really going to hurt performance. Take the time to rewrite your file storage code to use Blob storage, and just store the URI in your database (DocumentDB’s “attachments” feature actually does this for you, automatically). If you’re using an off-the-shelf CMS or blog engine, most of them have plugins available to store uploaded files in Azure Blobs. You’ll save money and your site or application will run faster. You can also use Blob Storage accounts as end-points for the Azure Content Delivery Network (CDN), allowing you to upload your data to a single point and have it served through nearly thirty data-centres around the world. TABLE STORAGE Azure Table Storage is what’s technically known as a “Key-Value store”, like Cassandra or DynamoDB. That means it scores highly for performance, scalability and flexibility, but not so great for complexity or functionality. Azure Tables have no schema: an Azure Table entity is a collection of key-value pairs, and entities within a table can have different keys. There are no indexes, no cross-table joins, and no real transactional capabilities.

So what can you use Table Storage for? All sorts of things! Anything where you just need really quick, scalable storage and retrieval of individual records. In my Azure applications, I use Table Storage for system concerns like User tables, configuration, and Session data. It’s a great repository for logging or audit data, and libraries like log4net, NLog and Serilog all support Table Storage as a target. My rule of thumb here is: start with the simplest thing; if it works, use it; if you need more features, look at the next simplest thing. QUEUE STORAGE As mentioned earlier, there are now a variety of messaging solutions available in Azure, and Service Bus in particular is far more powerful than Azure Queue Storage. It supports topics and pub/sub models, as well as providing similar basic queue functionality. If you need: very low latency messaging; to send messages to multiple receivers; to store messages for more than a week; or to send messages larger than 64KB; then use Service Bus. If, however, your requirements are simpler, Queue Storage is still a good option. The most common use case is for scheduling background operations to run in Worker roles or Azure Web Jobs, but I’ve also seen Queues used as a data synchronization mechanism to push arbitrary data to on-premises systems. As with Tables, if Queue Storage meets your requirements then use it. If it doesn’t, use Service Bus.

FILE SERVICE This is a recent addition to Azure Storage Services, and a very welcome one. Until the File Service launched, if you wanted a persistent File System in a Cloud Service or Virtual Machine, you had to create a Cloud Drive: a VHD held in Blob Storage as a Page Blob. These “drives” could be mounted to multiple server instances at a time, but only one would have write access. And if you wanted to get the files off the drive, you’d have to download the VHD and mount it locally. File Service offers a much simpler solution. You create “Shares”, which you can then access as SMB (Samba) network drives from Windows or Linux running in Azure. Multiple instances can read and write to these network drives simultaneously, and systems outside Azure can use a REST API or one of the SDKs to access the contents directly. CROSS-SERVICE FEATURES All these services benefit from several fundamental features. You can choose from various redundancy levels, from the cheapest, “Local Redundancy”, which stores three copies of each piece of data within the same datacentre, through other options which store additional copies in another

data-centre, and in the most powerful case, provide read-only access to that data through the secondary datacentre, which is great for reporting and data-warehousing. You can also opt-in to extensive metrics and analytics that provide complete and comprehensive data on operations, bandwidth and storage space used for all services, down to minute-by-minute stats. With Blob, Table and Queue storage, you can create Shared Access Signatures (SAS) to allow explicitly-limited (e.g. read-only or write-only) direct access to the service via the HTTP API or one of the many SDKs, so mobile applications can store and retrieve data without you needing to maintain and run a web service. You can also set up Cross-Origin Resource Sharing rules so that sites running on specific domains can use a SAS to read or write directly to the service as well. So, whether you already have systems running in Azure, or are considering building or migrating an application to run there, take some time to see if some or all of these services can boost your performance, increase your scalability, or just save you some money.

BECOME A CERTIFIED SCRUMMASTER OR A PRODUCT OWNER WITH MIKE COHN

Certified ScrumMaster - CSM 2 days: 15. December in Oslo Certified Scrum Product Owner - CSPO 2 days: 17. December in Oslo

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

Mark is the founder and CEO of Oort Corporation, a new company building cloud-based software for people who build cloud-based software. Oort's first product,Zudio, a webbased Windows Azure Storage toolkit, launched in April 2013. Mark has been a Windows Azure Development MVP for three years. In his spare time, Mark work's on the Simple.Data not-an-ORM and Simple.Web projects, and wanders the world speaking at conferences and user groups. Or he just geeks out learning new programming languages and frameworks; in 2013 he's working a lot with TypeScript and AngularJS.

Programming in Functional Style 24. November in Oslo with Venkat Subramaniam 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.

JAVA 8 IN A DAY

with Venkat Subramaniam The Java 8 release has brought the biggest and much needed change to the arguably most powerful programming language in mainstream use today. The new syntactical additions are relatively small, but the semantic difference that makes is large. Why is that? What are the reasons why Java decided to introduce yet another programming paradigm? How can we benefit from these new features?

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

International Developers in London International Developers in London is a group of meetup events conceived in early 2013, starting with a group for Italian speaking developers in London. Since this early inception, Adam (the host) has organised events for French, Spanish, Portuguese and Polish speaking developers in London.

Presentations are given in English to help people with their presentational skills. We will be represented by Adam in the community zone at NDC-London, or you can see more at www.idinlondon.co.uk.

Community is at the heart of what we do, with 2 technical talks at every meetup (on diverse topics such as Arduino development, Javascript coding, Design, Agile methodologies and TDD to name a few) given by the members, for the members.

ÂŠ Vudhikrai/Shutterstock

Unlock the value of your data with ElasticSearch By Tarjei Romtveit

We are living in the data age, with endless and ever growing amounts of data. It may sound like a clichĂŠ; but data driven decision-making is one of the most important differentiators for successful businesses. Amazon, Google, Wal-Mart, Yahoo, Facebook and Dell are all examples of global behemoths that crunch a lot of data. They use data-driven insights to drive and shape ad campaigns, social campaigns, product placement etc. The quality and accuracy of their sys-

tems is mainly driven by large amounts of data collected both externally and internally. This intense crunching of data, thankfully leads to great open source technology and best practices that are shared with to the outside world. Hadoop and Cassandra are just

two examples in this industry. A common trait of the tools are that they are all linearly scalable it the terms of processing and storage and supported by an external open source community. However, the learning curve is often quite steep before you

can put them into production and many smaller organizations have hesitated to deploy them. But gaining actionable insights from large amounts of data doesn’t have to be that difficult. You don’t necessarily need a full Hadoop environment to make sense of your data. Let’s take a look at a typical use case for a smaller company, and let’s see how we can make sense of data with the help of ElasticSearch. Elas-

ticSearch is a great technology that is both easy to learn, feature rich and with great scalability out of the box. THE USE CASE: ACME INC ACME Inc is a mid sized company that sells electronic components through an online store and mainly utilizes social media channels to target consumers. ACME collects a lot of information about their operations into an

ERP system that contains massive amounts of sales and inventory information. In addition, they store analytics data from Facebook and the other media channels that they use for outbound communications. We assume that the ERP system has a JSON API where you can export transactional history. The data format is shown in Fig. 1:

Fig 1.

Lets assume that all these entries are downloaded into a file called aBunchOfSalesData.txt and we have an installation of ElasticSearch running locally. We can then index the data into ElasticSearch through the bulk API by using this curl command: curl -s -XPUT localhost:9200/ _bulk --data-binary @aBunchOfSalesData.txt

You can test that the insertion was correct by running a search query: http://localhost:9200/acme/sales/_ search?q=*&pretty=yes

At the same time, ACME has a system for querying the Facebook Insight API every hour for updates and store it in a document store. This can be indexed by using the bulk API and the format is shown in Fig 2. Letâ&#x20AC;&#x2122;s say the CMO at ACME wants to understand if the money spent in their Facebook ad-campaign actually generates sales. The ad-campaign basically consists of a product ad being written on the ACME Facebook page and promoted to all of their followers. Since ElasticSearch have both historic sales information and historic Facebook

data, we can create a query to try to answer the CMOs question. It would be beneficial to get a timeline view with both sales data and the most important metrics from Facebook. If there are any positive correlations it could indicate that the campaign did work. To perform this query we utilize the very powerful aggregation feature, together with the equally strong date and time functions in ElasticSearch. The JSON query we use to extract the information is displayed in Fig 3 on the next page:

Fig 2.

F# VIA MACHINE LEARNING WORKSHOP Mathias Brandewinder

Machine Learning and Functional Programming are both very hot topics these days; they are also both rather intimidating for the beginner. In this workshop, we'll take a 100% hands-on approach, and learn practical ideas from Machine Learning, by tackling real-world problems and implementing solutions in F#, in a functional style.

8. December 2 days NOK 6900

DESIGN AND IMPLEMENTATION OF MICROSERVICES Sam Newman

Microservices Architecture is a concept that aims to decouple a solution by decomposing functionality into discrete services. Microservice architectures can lead to easily changeable, maintainable systems that can be more secure, performant and stable.

KOTLIN WORKSHOP Hadi Hariri

Kotlin is gaining a lot of traction. Close to release, there are already many companies and individuals that are shipping production code in Kotlin, with some having called it the Swift for Android.

12. January 1 day NOK 4900

28. November 1 day NOK 4900

F O R C O M P L E T E C O U R S E D E S C R I P T I O N S , T I M E A N D P L AC E , V I S I T W W W. P R O G R A M U T V I K L I N G . N O

Fig 3.

At first glance, the query displayed in Fig 3 looks quite verbose, but this is everything we need to be able to make an hourly comparison of the Facebook post views and the net total sales during the past 48 hours. In most other systems you will need to run several queries and maybe do the hourly aggregations manually in the application layer. Two of the reasons you do not need to run multiple

sub-queries, is that you are able to query two entirely different indexes without joins and apply the powerful nested aggregation feature. The nested aggregation feature is able to calculate values based on the output of its parent aggregation that completely removes the need for traversal in ACMEs application layer. The result of all these features is that you can add data types as they emerge and

just make small changes to a single query to be able to get comparable answers immediately. The output of the query is a list of all the hits and several aggregations called buckets. Each of these buckets contains the aggregations of “netTotal”, “views” and any other data we want to aggregate. To be able to visualize the result of the queries, you can use

the ElasticSearch Kibana dashboard. Another option is to feed the JSON data to a slightly more sophisticated graphing tool like D3.js or Google Charts. An example graph output from the query we ran earlier is shown in Fig 4. Fig 4 shows that the accumulated post views are increasing heavily quite early

in the morning. Around the same time, the amount of sales peaks at 70 000 K NOKs for the campaigned product. However a few further questions emerge by just looking at the data in the graph. What triggers the peak late in the evening of 23.09? What other products and product ranges are leveraged in the same period? How many customer transactions and how many

items per transaction are there in the campaign period? To answer these questions you may have to add some more data and extend the query and run the process again iteratively until your CMO is satisfied, but the opportunities are endless.

versatile and flexible in handling different data types, and not only fulltext search. The query language and APIs enable you to quickly explore your data and unlock the value of the

data and rapidly improve your results. Go try it out yourself!

Fig 4.

CONCLUSION We have looked at a typical business question, added some data and tried to query ElasticSearch for an answer. We have seen that ElasticSearch is hugely

Tarjei Romtveit is a senior consultant and co-founder of Monokkel A/S. Monokkel is a consulting company that focuses on all things data. Before founding Monokkel; Tarjei was CTO at a Norwegian social media analytics and intelligence start-up Integrasco A/S. In this company Tarjei solved big data related problems on a daily basis since 2006.

Aspose.Words

Aspose.Email

Aspose.Pdf

Aspose.BarCode

Aspose.Cells

Aspose.Imaging

Aspose.Slides

Aspose.Tasks ... and many more

100% Standalone - No Office Automation

a EU: +44 141 416 1112 sales.europe@aspose.com 29

Architecture for CD

ÂŠ Ron Dale / Shutterstock

By Rachel Laycock

A few years ago a client asked for us (ThoughtWorks) to help them to implement Continuously Delivery in their organisation. They were on six monthly release cycles which were painful and fraught with risk, requiring the entire development, testing and operations team to come in for a whole weekend to release their products, sometimes several if the first attempt wasn't successful. An executive read the Continuous Delivery book and decided they wanted to and needed to deliver much more rapidly to continue to compete in the market. We of course said “sure”. My team had all being delivering software using the principles and practices of Continuous Delivery for years. But… Three months later the executives were asking “where is my Continuous Delivery?”. We had failed to implement CD in any meaningful way. So what went wrong? How did we fail at something we knew how to do and had done on many projects before? Their code based was huge and complex - over 70 million lines of code and millions of dependencies. To be blunt, their architecture was a mess. There are specific considerations for your architecture when you are deploying early and often. You put your software in operational mode early - which is good. But what does this mean to how you design and architect your system? Especially if you would like to achieve continuous delivery and you have existing “balls of mud”. My experience left me with three considerations: 1. Conway’s Law is the law 2. Keep things small 3. Evolve your architecture

CONWAY’S LAW IS THE LAW One of the main reasons software architecture is so hard is because of it’s fundamental link between an organisation's structure. Also known as the people and process. Once you get humans involved in any problem then you now have a very complex problem to solve. Conway's Law states: "organisations which design systems ... are constrained to designs which are copies of the communication structures of these organisations".

specific. Because they were all in the same monolith when changes were made it affected everyone regardless of whether than made sense to that region. This was causing problems getting software out of the door. They were tripping over one another during release time, breaking shared components to meet their own needs. Eventually they had enough and decided they needed to make some fundamental changes in order to continuously delivery.

The most explicit example I have seen of this is the monolith problem.

Most organisations that have a monolith system with teams broken up into specialists like UI developers, Java developers and Database developers, many of the issues are at the seams of the communications between these specialisms. This problem presents itself in many ways; bottlenecks or wait time in your delivery cycle for any feature that requires more than one specialised team, code being put in weird places just because it needs to be there but your specialism can’t actually check-in to any of the layers that are owned by another team. The latter issue is eloquently described by Fred Brooks in the Mythical Man Month, “Because the design that occurs first is almost never the best possible, the prevailing system concept may need to change. Therefore, flexibility of organisation is important to effective design.” With a specialized inflexible team structure like this you are likely to either get stuck with your original design - good or bad - or your abstractions will start to leak as you put thing like business logic wherever you can rather than where they should go from a sound design perspective. I’ve seen many teams fall on the wrong side of Conway’s Law and end up with the dreaded “ball of mud” architecture. But there is hope. You can leverage Conway’s Law to your advantage. Another client had a similar monolith problem... The had built an monolith application whose users were country based e.g. Australia, Italy, UK. Many of their requirements were the same, but many were region

First they re-organised their specialists to create feature teams; these teams were made up of all the skills they needed to create their full stack from UI developers to the database. These new teams needed to figure out what was really shared and what was not, but initially they just needed to get stuff to production. So, they forked the code base. They now all had their own code, which meant they could release independently, but it did not solve the problem of figuring out what was shared. They had to create a “scrum of scrums” to decide as a group what were the shared components. Because they had been burned badly by sharing they were very careful to be absolutely certain it really was a fundamental component that would rarely change. They did this one small single responsibility at a time. The end result of these shared components were micro services. KEEP THINGS SMALL Micro-services can be loosely defined as “fine grained SOA” or as some people refer to it “SOA done right given what we have learned about SOA done wrong and automation of our deployments and infrastructure configuration”, but that wouldn’t be as catchy. They are small, run on independent processes and decoupled enough that they can be deployed independently. Much of their appeal lies in being able to use “the right tool for the job” instead of the golden hammer approach and in the ability to build in resilience that would be difficult to do in a monolith system. They can also be scaled independently and easily replaced as long as you keep them small and follow the single responsibility principle. But this is not a free lunch…

Microservices move communication and complexity into your infrastructure, which increases the cognitive load of your architecture. And to get the resilience benefits you have to build it. Monitoring your system becomes as important as writing tests for it, you need a decent versioning strategy and a very high level of automation of your deployment and environment configuration to deploy and run these services in independent processes with confidence. Neal Ford put it best when he said recently “You have to be this tall to use micro-services”. Meaning a high level of maturity needs to be achieved in things like automated and deployment before micro services can be for you. Otherwise you will end up with a much worse problem than the monolithic one.

and operational early and often. The world of software architecture has changed as a result. We now have to architect for build, run and deploy. Structure your teams how you want your software to look and create communication structures for the interconnected pieces. You will need to keep working at this because you are unlikely to get it right the first time. None of us do.

EVOLVE YOUR ARCHITECTURE Finally, as you will be operationalises your software early you need to be able to evolve your architecture. Neal Ford in his IBM series talks about Evolutionary Architecture and Emergent Design. There are 5 principles to Evolutionary Architecture: 1. The Last Responsible Moment 2. Architect for Evolvability 3. Postel’s Law 4. Architect for Testability 5. Conway’s Law I recommend reading the series to get more details on each of these principles. There are many considerations to concern yourself with in the architecture of your system, but not all will be prioritised equally for the problems your organisation is trying to solve. These principles will guide you to only solve those you need to now and leave the rest for a later point in time, but not irresponsibly late! Since the world of Continuous Delivery has started to become the norm, we are finding ourselves in deployment

Rachel Laycock works for ThoughtWorks as a Market Technical Principal with over 10 years of experience in systems development. She has worked on a wide range of technologies and the integration of many disparate systems. Since working at ThoughtWorks, Rachel has coached teams on Agile and Continuous Delivery technical practices and has played the role of coach, trainer, technical lead, architect, and developer. She is now a member of the Technical Advisory Board to the CTO, which regularly produces the ThoughtWorks Technology Radar. Rachel is fascinated by problem solving and has discovered that people problems are often more difficult to solve than software ones.

ÂŠ alphaspirit/Shutterstock

Creativity and Innovation:

CRITICAL TOOLS FOR SUSTAINED SUCCESS The landscape of business has changed dramatically over the past several years. For decades, the focus has been on cost control and technology, whereas the current business climate has prompted a paradigm shift. Success for companies in the 21st century is now dependent upon creativity and innovation, both hailed as the most important contributors to the growth of the economy. By Denise Jacobs

Creativity is the ability to develop meaningful new ideas through exercising imagination and originality. Contrary to popular belief, creativity is not relegated to a select few: we are all born creative. However, creativity is like a muscle: it grows stronger with repeated practice and exercise – and weaker with disuse.

organizations merely pay lip service to the importance of creative thinking and having an innovation mindset, but do little to support it. These are the companies that encourage people to take risks and be innovative, but then punish them when they make mistakes or their ideas aren’t immediately lucrative.

Innovation is the practice of making changes to that which is established, using creativity to enhance and improve upon known concepts, practices, or processes. Similar to creativity, an innovation mindset becomes ingrained through building the habit of thinking in certain ways, and is sustained through a supportive environment.

The sad thing about both of the above scenarios is the supreme waste talent and resources that they produce. Brilliant employees become unmotivated and bored, merely going through the motions of their jobs, and the company’s greatest source of creativity and innovation lay dormant.

PROBLEMS AND SOLUTIONS Unfortunately, despite recognizing creativity and innovation as critical tools for sustained success, many companies are slow to adapt to this new environment. At best, the few business leaders who truly understand how critical it is to initiate the shift within their organizations are at a loss at how to start the process. At worst,

The good news is that leveraging the untapped, latent talents of the members of an organization can reverse this downward spiral. Through reigniting your workforce’s creative spark and inspiring innovation at all levels – from the top down and the bottom up – companies will be well on their way to improving employee engagement by helping people feel connected to and passionate about

their work and their ability to meaningfully contribute to their company. Therefore, training your employees on creative thinking and innovation skills so that they not only understand the power of creative thinking, but they also have the tools to do so should be a top priority for your organization. FOUR TIPS FOR REIGNITING CREATIVITY AND INSPIRING INNOVATION Whether you need to instill the creative spirit or revive flagging creative inspiration with the members of your organization, here are four ways to do so: 1. Help individuals and teams get unblocked creatively Often, the biggest blocks to creative, innovative thinking come from fears: fear of making a mistake and fear of failure. Further, people often feel creatively stymied when they perceive that there are no proper outlets for sharing ideas: that they’ll be criticized for original thinking, or that their unique concepts will be dismissed. Make it a policy to be more open-minded and to suspend judgment on ideas – especially in the early stages – and particularly with the unusual or seemingly random ideas. Encourage spontaneity and experimentation, and give people the responsibility and freedom to make mistakes.

2. Advocate and practice effective communication Creativity and innovation flourish most in groups where there is fantastic communication: the sharing, listening to, and amplification of ideas – not only amongst the team members with customers as well. Effective communication has two sides: listening and sharing. People with the best ideas are most often those who are adept listeners and so are the best leaders. They are stimulated by the concepts of others and connect the dots in novel ways to create even better ideas. Listening well requires being present, giving people your full attention, and relaxing your own agenda. Doing so allows you to hear the brilliance in others. Almost as important as listening is being able to clearly articulate and share ideas. In fact, companies with highly creative cultures support their employees in idea-selling, because “it’s not about good ideas. It’s about selling those ideas and making them happen,” according to Marketing guru Seth Godin. Learning presenting skills a great way to give people the tools and the confidence to articulate and sell their concepts, making it easier for their great ideas to gain traction within the team and company. By learning to become excellent listeners and generous sharers, team members will become master communicators who practice a dynamic, responsive, and generous sharing and exchange of ideas.

The more comfortable people feel with being able to fail and try again with fewer repercussions, the more they relax their guard and allow ideas to flow. They will relearn how to trust their creative “gut”, and start the process of breaking down their creative blocks.

3. Champion a culture of creative collaboration Forget the mythology of the lone genius cranking out innovations from a garage. People coming together to share ideas, compare observations, and brainstorm solutions to complex problems power inspired creativity and sustained innovation. Fostering and harnessing the creative abilities of a group produces a wider range of creative ideas and innovative solutions arising from the range of knowledge, experience, and perspectives of the individuals of the group. One of the best ways to help the people within your teams to create better together is to teach people to amplify the creative ideas of others. Our tendency is to try to find problems with another’s ideas, which brings ideations to standstill. However, ideas blossom when team members to get in the habit of responding to a offered idea not with a “Yes, but…”, but instead with a “Yes, AND…”.

must be available in order to support the workforce in implementing their creative and innovative processes and products. Individuals and teams need the space to generate, develop, and experiment on ideas. Because of this, one of the most critical resources that encourage and support creativity and innovation is time. The best example of this is Google’s 20% time, which has created some of the most successful Google products. But time is not enough. Make sure there is budget for taking great ideas to the next level. Ensure that your initiative to cultivate creativity and spur innovation is strengthened by trainings and medium to long-term programs. Doing so will help build teams that are synergistic and can produce well together when it’s time to start moving their grand ideas to market. WELL-WORTH THE EFFORT Once you get on-board with promoting creativity and innovation within your organization, you’ll wonder why you didn’t do it sooner. Even in the short-term, you’ll begin to see benefits such as improved teamwork and team cohesion, better employee engagement and productivity, increased attraction and retention of talented employees, and enhanced problem-solving and interaction. By providing the resources that sustain and grow an enduring culture of creativity and innovation, you’ll make it safe for people in your organization to bust through their creative blocks in order to grow their ideas and experiment with them, generously listen to and share ideas, and creatively collaborate to generate innovative solutions as a team. The companies that prevail in upcoming years will boast both a creative and innovative leadership and workforce that, in tandem, will skyrocket the success of the company’s products and services. So, are you ready to make a commitment to igniting creativity and inspiring innovation within your organization? Make the effort, and you’ll see how you can transform how you and your team work… for the better. Encouraging teaching and learning within the team is also powerful. Creating a culture of mentorship facilitates the brain-share of the more experienced members with the more junior, and not only brings up the whole level of the team, but also strengthens connections and trust, fueling strong collaboration down the road. Brand-new members coming into the team should be on-boarded with the innovation mindset of the group, so that they come into their new work environment ready to develop and share their ideas. The trust built by these dynamics binds the team members together in productive collaboration. 4. Provide the resources to support and execute upon great ideas It’s one thing to talk the creativity and innovation talk, but to actually walk that talk, the very necessary resources of time, money, manpower, training/methods, and materials

Denise Jacobs is a Speaker + Author who speaks at conferences and consults with companies worldwide. As the Founder + Chief Creativity Evangelist of The Creative Dose, she teaches techniques to make the creative process more fluid, methods for making work environments more conducive to creative productivity, and practices for sparking innovation. She is the author of The CSS Detective Guide, and co-authored the Smashing Book #3 1/3 and Interact with Web Standards. Denise is the Chief Unicorn of Rawk The Web, and the Head Instigator of The Creativity (R)Evolution.

ÂŠ Photosani/Shutterstock

THINKING LIKE AN ERLANGER – Part 1 You will hear people talking about Erlang being different, I, for one, am putting that statement forward. By being different I'm not referring to the peculiar syntax Erlang has due to its first interpreter being written in Prolog. No. What makes Erlang truly different is the Golden Trinity of Erlang. By Torben Hoffmann

The three principles and their interaction that sets Erlang apart are: * share nothing processes communicating with message passing * fail fast approach to errors; let the processes fail when they err * failure handling by using supervision of processes by other processes One thing is to understand what each of them means, another thing is to understand how they work together and yet another thing is how to apply them when developing a program. In this article I will not go into lengthy explanation of how the Golden Trinity of Erlang (see figure on the left) plays out, but rather focus on showing how to think with the principles as we look at the creation of an Erlang program. In this article we will look at processes and how to program with asynchronous message passing. In later articles we will deal with fail fast and failure handling. GAME OF LIFE Conway's famous Game of Life (GOL) [https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life]

is the example we will look at in this article.

GOL is a zero-player game where a number of cells arranged in a 2-dimensional grid evolve over time in a step-wise manner based on the configuration of the grid.

The rules for the state - alive or dead - of a cell in the next step are simple: . Any live cell with less than 2 neighbours dies. . Any live cell with 2 or 3 neighbours survives. . Any live cell with more than 3 neighbours dies. . Any dead cell with exactly 3 neighbours becomes alive. The typical way of representing a GOL world is to use a – not surprisingly – 2-dimensional array. You could do that in Erlang too, but that is not the Erlang way! PROCESSES, PROCESSES, PROCESSES When you want something done in Erlang you throw processes at it. In object-oriented languages you think in objects. In Erlang the cheap resource is processes, which the run-time provides in a very lightweight manner allowing the creation of 136.000 processes on a Raspberry-Pi! So for GOL the Erlang way is to let each cell in the grid be a process. When computing the next value the cell needs to know the status of each of its neighbours. The only way the processes can communicate in Erlang is by message passing, so the cell process has to send a message to each of its neighbours and collect the answers to count the number of neighbours it has.

query_neighbours(T, Neighbours) -> lists:foreach( fun(N) -> N ! {self(), {get, T}} end, Neighbours).

Here Neighbours is a list of Pids and T is the current time in the simulation. After sending messages to all its neighbours the process starts collecting answers and responding to requests form its neighbours: collecting(#state{time=Time, content=C, xy=XY}=State, NeighbourCount, WaitingOn) -> receive {From, {get, Time}} -> C -> From ! {cell_content, {{XY,Time},C}}, collecting(State, NeighbourCount, WaitingOn); {cell_content, {{{_X,_Y},Time}=XYatT, NeighbourContent}} -> collecting(State, NeighbourCount + NeighbourContent, lists:delete(XYatT, WaitingOn)) end.

So if a neighbour queries a cell for its value ({get, Time}) the response is sent back to the requesting process as a tuple {cell_content, {{XY, Time}, C}} and the cell continues its loop. If a reply comes back from one of the neighbours the NeighbourCount is updated and the neighbour is removed from the list of neighbours the cell is waiting on. When there are no more neighbours to collect from the cell updates its state to the next point in time: collecting(#state{xy=XY, content=Content, time=T, history=History}=State, NeighbourCount, []) -> NextContent = next_content(Content, NeighbourCount), lager:info("Cell ~p changing to ~p for time ~p", [XY, NextContent, T+1]), State#state{content=NextContent, time=T+1, history=[{T, Content}|History];

This code is straightforward: it figures out what the new content of the cell should be based on how many neighbours it has (the next_count/1 function) and then incements time and history for the state of the cell. ALL IS WELL, RIGHT? Not really. We have dealt with the first problem when it comes to making processes communicate between one another: asking for information and replying to queries. If we run this code one time step at a time it will be fine. We will get all the cells to update and once they are done we can do the next step. But if we let the cells run freely, i.e., proceed as fast as they can from one time step to the next they will quickly come out of sync. E.g., the first cell to go to time T=2 will

start asking for cell content that its neighbours have not computed yet and their requests for the cell content at T=1 hits the cell it will not have a message clause to match the incoming request since it is now looking for {From, {get, 2}} messages and not {From, {get, 1}} messages. This is a problem that is painfully obvious and hits you really fast with the Game of Life simulation, but when you are doing distributed systems this problem is often a lot harder to spot and tends to hit you when you least expect it.

So how does one go about solving such a problem with processes getting slightly out of sync without resorting to synchronous solutions? You have to provide two things in the processes: 1. Dealing with being ahead of the rest. 2. Dealing with being behind the rest. For our Game of Life we solve the problem of being ahead by introducing a function that uses the history of the cell to give replies to neighbours that are behind: content_at(Time, #state{xy=XY, time=Time, content=Content}) -> {{XY,Time}, Content}; content_at(Time, #state{xy=XY, history=History}) when is_integer(Time), Time >= 0-> {_, Content} = lists:keyfind(Time, 1, History), {{XY, Time}, Content}.

Solving being behind requires a bit more work. First we change content_at/2 to return the atom future if the value has not been calculated yet: content_at(Time, #state{time=T}) when Time > T -> future;

Now we can write the handling of requests like this: receive {From, {get, Time}} -> case content_at(Time, State) of future -> collecting(State#state{future=[{From, Time}|State#state.future]}, NeighbourCount, WaitingOn); C -> From ! {cell_content, C}, collecting(State, NeighbourCount, WaitingOn) end; ...

So if someone wants something that we consider the future we add the request to the future list in our state and carry on.

Those future requests collected are then resolved when the cell computes its next step: collecting(#state{xy=XY, content=Content, time=T, history=History, future=Future}=State, NeighbourCount, []) -> NextContent = next_content(Content, NeighbourCount), NewFuture = process_future(XY, T+1, NextContent, Future), lager:info("Cell ~p changing to ~p for time ~p", [XY, NextContent, T+1]), State#state{content=NextContent, time=T+1, history=[{T, Content}|History], future=NewFuture};

The process_future/2 function simply sends replies to those waiting on this new value: process_future(XY, Time, Content, Future) -> {Ready, NewFuture} = lists:partition( fun({_Pid,T}) -> T == Time end, Future), lists:foreach( fun({Pid,_}) -> Pid ! {cell_content, {{XY,Time}, Content}} end, Ready), NewFuture.

It takes all those waiting on the current Time and sends them a message and keeps the rest as they are even further out in the future. WRAPPING UP Dealing with asynchronous message passing can be a bit tricky, but the rewards in terms of making your system more scalable are so great that it is worth it. The Reactive Manifesto [http://www.reactivemanifesto.org] also embraces asynchronous message passing and Erlang is a wonderful language for doing reactive systems in that spirit. If you want to play with the entire code base for Game of Life you can go to [https://github.com/lehoff/egol] and clone it. The tag ndc1 has the commit that was used to create the final version of the code for this article. In part 2 of Thinking like an Erlanger I will look at fail fast and supervision so that we can make Game of Life more robust. Torben is the CTO of Erlang Solutions and has been working with Erlang in Motorola and Issuu as technical architect and developer since 2006. He has talked about his Motorola achievements at Erlang eXchange 2008 and EUC 2010. He has been holding the Erlang banner high as a self confessed Erlang Priest at several conferences such as CodeMesh, Build Stuff, Goto, Craft and Lambda Days. Before becoming an Erlanger he worked with software quality assurance, process improvement and people management. 42

Isn’t it time to reignite your team’s creative spark, inspire innovation, and cultivate collaboration? We can help.

We transform how you and your team work…for the better. Discover our leading-edge approach to creative inspiration and thinking, idea generation and execution, and effective communication and team cohesion that will skyrocket engagement, innovation, and productivity. We’re available and at the ready for workshops, consulting, keynotes/ playnotes/speaking, and coaching.

Work Better. Produce More. Create Betterness. Come see us in action at NDC People, February 2015 in Oslo, Norway! For more information and to register, visit people.ndcevents.com.

TheCreativeDose.com

A CREATIVITY + INNOVATION COLLECTIVE

Create a CUSTOM

AGILE PROCESS for Your Organization

By Stephen Forte

I’ve been working with Scrum since its earliest days and over the past few years have had the privilege of getting to sit on the board of directors of the Scrum Alliance. From this vantage point I have observed that collectively as an industry, we suffer from “Scrumbutaphobia”. This is the fear that we are doing Scrum wrong and are not following the Scrum “rules” also know as “Scrum But”. (When asked if you are using Scrum in your organization and answer: “I am doing Scrum, but…”)

This fear comes from the fact that we all have taken Scrum to its limits, modified it beyond the â&#x20AC;&#x153;rulesâ&#x20AC;? to suit our needs, and implemented something that looks and feels like Scrum in our organization-usually with success. That said, even successful organizations have Scrumbutaphobia. OVERCOMING SCRUMBUTAPHOBIA This is crazy; Agile is all about embracing change! When asked what kind of methodology they were using in their organization in an industry survey, organizations adhering to a single Agile methodology was only 31%. Organizations using mixed methodologies, both Agile and non-Agile, was 67%. You are not alone.

Instead of fearing the changes you have made to Scrum, why not embrace them? It is entirely possible, downright preferable, to build your own agile process in your organization. There is a fairly simple process you can put in place to build your own Agile process. You may build a unique process for each project in your organization if the characteristics of each project are different. BUILDING A UNIQUE AGILE PROCESS FOR YOUR ORGANIZATION First start with the values of the Agile Manifesto. When you look at it, Agile is set of values, not rules. Understanding these values above all else will help you transform your organization.

From XP • User Stories • Pair Programming • Continuous Integration From Scrum • Use Sprints of fixed duration • Daily (virtual) Scrum meeting From Kanban • Make Process Policies Explicit • Use Models to Suggest Improvement As you build your new Agile process remember to always adhere to the values of the Agile manifesto. In addition, remember that once you have built the process, remember to check in all the time and suggest improvements. No process should remain static. Be Agile and embrace change!

Then look at most popular “brands” of Agile: XP, Scrum, and Kanban. Look at all of their features or rules. For example you can think of something like this short (and incomplete) list of “features” of each Agile brand: XP • Pair Programming • TDD • Co-location • User Stories Scrum • Time boxed work (aka “Sprints”) • Cross-functional team • Daily Scrum meeting • Product Owner manages the backlog Kanban • Limited Work in Progress • Make process policies explicit • Measure and Manage Flow • Visualized Workflow After you have all of the features of each brand put them out on the whiteboard or use sticky notes and then design your process. For example, your current project may have the following characteristics: • Remote team in different time zones • Greenfield project • Project uses contractors Now map the features that are useful from each Agile brand to your project’s needs. You may come up with something like this:

Stephen Forte is the Chief Strategy Officer of Telerik, a leading vendor of developer and team productivity tools. Stephen is also a board member of the Scrum Alliance. Involved in several startups, he was the co-founder of Triton Works, which was acquired by UBM (London: UBM.L) in 2010 and was the Chief Technology Officer and co-founder of Corzen, Inc., which was acquired by Wanted Technologies (TXV: WAN) in 2007. Stephen also speaks regularly at industry conferences around the world. He has written several books on application and database development including Programming SQL Server 2008 (MS Press). Prior to Corzen, Stephen served as the CTO of Zagat Survey in New York City (acquired by Google in 2011) and also was co-founder of the New York-based software consulting firm The Aurora Development Group. He currently is a Microsoft MVP award recipient, Microsoft Regional Director, INETA speaker, and is the co-moderator and founder of the NYC .NET Developer User Group. Stephen is also a Certified Scrum Professional and PMP and holds an MBA from the City University of New York. An avid mountain climber, Stephen leads a trek in the Mt. Everest region every fall to raise money for charity. Stephen lives in Hong Kong with his wife.

Photo: Shutterstock

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 â&#x20AC;&#x153;practical, applicable knowledgeâ&#x20AC;? 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.ndc-london.com www.ndcoslo.com

ÂŠ totallyPic/ Shutterstock

EXCEPTIONAL NAMING By Kevlin Henney

One of the hardest things in software development is naming. Naming of products, of paradigms and of parts of your code. The reason naming is both hard and important is because it is an act of communication; without good names your code might as well be written in, well, code.

We often adopt conventions to make some aspects of naming easier, but while such consistency is often a good thing, some practices are flawed from the outset. Although having a common vocabulary of concepts is useful across a codebase, the basis of the consistency must be useful otherwise it's just noise and can become homeopathic: programmers make names longer by adding more words but end up diluting the meaning of their code with every Factory/Manager/Object/Controller/Aggregate/ Value they add. One such ritual common to both the .NET and the Java worlds is adding the suffix Exception to a class to denote that its instances are exceptions. Exceptions are privileged in the language, meaning that they appear in specific and compiler-enforced places in your code: in a throw, in a catch and, in the case of the Java, in a throws list. By definition things that appear in these places can only be exceptions; the reader already knows they are exceptions, so there's nothing more to add. Of course, there is also the definition of the exception class. That a class is an exception should be obvious either by its parentage or by its name. The name should represent whatever the problem is, and should do so directly and precisely. To add Exception to the end is either redundant — so remove it — or an indication of a poor name — so rename it. Consider, for example, the following core Java exception classes: ClassNotFoundException EnumConstantNotPresentException IllegalArgumentException IllegalAccessException IndexOutOfBoundsException NegativeArraySizeException NoSuchMethodException TypeNotPresentException UnsupportedOperationException Dropping the Exception suffix gives the following names: ClassNotFound EnumConstantNotPresent IllegalArgument IllegalAccess

IndexOutOfBounds NegativeArraySize NoSuchMethod TypeNotPresent UnsupportedOperation These names are more concise and perfectly descriptive. There is no question that these are exceptions. OK, but what about the following, also from the core Java exception classes? ArithmeticException ArrayStoreException ClassCastException InstantiationException NullPointerException SecurityException Dropping the Exception suffix results in the following: Arithmetic ArrayStore ClassCast Instantiation NullPointer Security Hmm, not so good. But is that a problem with dropping the Exception suffix? Or a problem revealed by dropping it? Let's try renaming these classes to the exceptions they actually represent: IntegerDivisionByZero IllegalArrayElementType CastToNonSubclass ClassCannotBeInstantiated NullDereferenced SecurityViolation These names are both accurate and precise, representing the actual exception condition without resorting to noise words. Is it an exception that a reference (or rather, a pointer) is null? Not at all: the exception is only thrown when a null is dereferenced, such as having a method called through it. Is security an exception? Not at all: a security violation is what is being signalled. Of particular interest is renaming ArithmeticException to IntegerDivisionByZero, which clarifies something many Java programmers are unaware of!

Just as you don't tag your verbs with Verb or your nouns with Noun when you write or speak, there is little reason — and many reasons not to — tag Exception onto the end of an exception class's name. In many cases it can be considered a code smell rather than a practice to follow, and can deprive programmers of the opportunity to choose a better name. The possible exception to this rule? The general class that indicates that its descendants are exceptions: Exception. But then again, that's not a suffix: that's the whole of its name and the concept that it represents, so perhaps there are no exceptions on Exception naming.

Kevlin is an independent consultant and trainer based in the UK. His development interests are in patterns, programming, practice and process. He has been a columnist for various magazines and web sites, including Better Software, The Register, Application Development Advisor, Java Report and the C/C++ Users Journal. Kevlin is co-author of A Pattern Language for Distributed Computing and On Patterns and Pattern Languages, two volumes in the Pattern-Oriented Software Architecture series. He is also editor of the 97 Things Every Programmer Should Know site and book.

From 1-day workshop to 5-days training 1 DAY 28. November DESIGN AND IMPLEMENTATION OF MICROSERVICES Sam Newman Microservices Architecture is a concept that aims to decouple a solution by decomposing functionality into discrete services. Microservice architectures can lead to easily changeable, maintainable systems that can be more secure, performant and stable. 1 Day Workshop. Kr 4 900,2 DAYS 8. December F# VIA MACHINE LEARNING WORKSHOP Mathias Brandewinder Machine Learning and Functional Programming are both very hot topics these days; they are also both rather intimidating for the beginner. In this workshop, we’ll take a 100% hands-on approach, and learn practical ideas from Machine Learning, by tackling realworld problems and implementing solutions in F#, in a functional style. 2 Day Workshop. Kr 4 900,Course EVOLUTIONARY DESIGN AND ARCHITECTURE FOR AGILE DEVELOPMENT Venkat Subramaniam This is where the principles and the practices we can learn and follow from evolutionary design and architecture comes in. This course will help us avoid the perils of upfront design, and at the same time, keep us away for the traps of inadequate or insufficient design. Learn how to create practical design that can efficiently balance the tradeoffs we face in architecting and designing software. Course PROGRAMMING IN FUNCTIONAL STYLE Venkat Subramaniam “Functional programming,” yes, everyone’s talking about it. But why? What’s this new excitement about something that’s been around for a very long time in some esoteric languages. For one thing, most mainstream languages now support it. C#, Java, C++,... To program in functional style you don’t have to change the language, but you have to change how you 50

program in that language. Change can be hard, but there are some nice rewards that go with it for those of us who are adaptive. Course REACTIVE PROGRAMMING WITH AKKA Venkat Subramaniam The course has a good balance of interactive lectures and hands-on exercises. The attendees are expected to pair-up and work on the lab exercises. The instructor will assist the attendees as they work on the exercises. Course PROGRAMMING IN JAVA 8 Venkat Subramaniam Java is arguably one of the most widely used languages. This popular language is going through a makeover. This will have a significant impact on how programmers will code and design applications with Java. With the introduction of lambda expressions and method references in Java 8, we can now make use of functional stye of programming. Course TEST-DRIVEN DEVELOPMENT Venkat Subramaniam Honing Your Test Driven Design Skills. The course has a good balance of interactive lectures and hands–on exercises. The attendees are expected to pair–up and work on the lab exercises. The instructor will assist the attendees as they work on the exercises. The objective of the course is for the attendees to gain an in depth practical knowledge of the concepts so they can put them to immediate use on real projects. Course TEST-DRIVEN DEVELOPMENT & REFACTORING TECHNIQUES Robert C. Martin Test Driven Development (TDD) is one of the most profound Agile development practices. It has been adopted by nearly all the Agile methods and there is documented evidence that it has reduced defect rates by a factor of ten.

Course CORE SPRING 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. Course FUNDAMENTALS OF ANDROID PROGRAMMING Wei-Meng Lee This course covers the latest version of Android using Android Studio. Course LEARNING SWIFT PROGRAMMING Wei-Meng Lee Apple announced the new Swift programming language at the Worldwide Developers Conference (WWDC) 2014. Course FUNDAMENTALS OF IOS PROGRAMMING Wei-Meng Lee The workshop will begin with the basic concepts such as Views, View Controllers, Protocols and Delegates, as well as the tools that help you develop compelling iOS applications – Xcode and Interface Builder. Course ADVANCED C++ PROGRAMMING AND INTRODUCTION TO C++11 Hubert Matthews This course is designed to introduce delegates to more advanced use of C++ as well as introducing the most common parts of C++11. Course JAVASCRIPT FOR PROGRAMMERS Christian Johansen The JavaScript programming language is covered in depth. Gain the necessary understanding of the language to work actively and effectively with the applications front–end. The course will take you through the entire

JavaScript language; from basic syntax and built–in types to its object model and functional elements, giving you a solid understanding of how JavaScript really works. Course BDD - SPECIFICATION BY EXAMPLE Gojko Adzic This two day course 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. Course ANGULARJS FUNDAMENTALS Scott Allen The AngularJS framework allows us to build testable applications using the common web standards of HTML, JavaScript, and CSS. This course comprehensively demonstrates the features of AngularJS by building an application using directives, filters, routing, controllers, templates, services, and views. Course BUILDING APPLICATIONS WITH JAVASCRIPT AND NODEJS? Scott Allen In this course we'll see how to build fast and lightweight applications using NodeJS. We'll build the entire stack using JavaScript from end to end, from MongoDB on the back to AngularJS on the front. Along the way we'll see how to deploy anddebug applications, as well as how to implement authentication and authorization. Course ARCHITECTURE WITH AGILITY Kevlin Henney Every system has an architecture, whether accidental or intentional, and regardless of whether it was put in place by a nominated architect or whether it emerged from the decisions and discussions of a team. All too often the focus of what is often described as architecture is centred around a specific set of platform

technologies, which forms only one part of the set of concerns an architecture should. And all too often architecture is seen as a separate concern from development process, whereas the two are intertwined — what you build is influenced by how you build it, and vice versa. Course AGILE DESIGN AND MODELING FOR ADVANCED OBJECT DESIGN WITH PATTERNS 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. Course NODE.JS/MEAN END-TO-END WEB DEVELOPMENT WORKSHOP Dan Wahlin Node.js is one of the most revolutionary frameworks to come out in quite a while! Its asynchronous nature and flexibility makes it relevant for building everything from Web applications to client tools and you’ll find it being used in a variety of ways. Node.js is based on JavaScript so if you’re already comfortable with the JavaScript language you can be productive with Node.js right away. In the Node.js/MEAN End-to-End Web Development Workshop you’ll learn how to build a Web application from start to finish using MongoDB, Express/Kraken, AngularJS, and Node.js (the MEAN stack). Topics covered include building model classes , connecting to MongoDB with Mongoose, securing a site with Passport, building a shopping cart with AngularJS and Node.js RESTful services, creating controllers and routes with Express and Kraken, binding data to views using Dust.js, and much more. If you’re looking to learn the ins-and-outs of Node.js then this 4 days course is for you!

Course 15. December CERTIFIED SCRUMMASTER (CSM) Mike Cohn This two day course, taught by author and popular Scrum and agile trainer Mike Cohn, not only provides the fundamental principles of Scrum, but also gives participants hands-on experience using Scrum. Course 17. December CERTIFIED SCRUM PRODUCT OWNER (CSPO) Mike Cohn Completion of this two day course results in participants becoming certified as recognised Scrum Product Owners. Course C#.NET: DEVELOPMENT IN .NET WITH C# Arjan Einbu In this course you will learn how to develop different types of applications in the .Net environment using the C# language. The course is intended for programmers, and focuses on what is useful to you as a developer. You will learn how to develop both Windows (Windows Forms and WPF) and web applications, libraries (.dll) and communication solutions with WCF. Course WEB DEVELOPMENT IN .NET - ASP.NET MVC , HTML5, CSS3, JAVASCRIPT Arjan Einbu This course covers everything you need to know to start building applications with the latest Microsoft web development stack. We will use ASP.NET MVC on the server and see how to work with models, views, and controllers. On the client we’ll take advantage of HTML 5, CSS 3, and the best JavaScript frameworks, including jQuery, Modernizr, and more.

COURSES continued Course - 2 days AGILE INNOVATION Jessie Shternshus and Denise Jacobs New best practices for creative problem-solving, communication, collaboration, and project execution. Most development projects rely on the assumption that the environment in which it is built is stable. However, software development environments are highly complex, in constant flux, and thus are unpredictable -not because of the software itself, but because of the people creating it. A project’s success is dependent upon the team communicating effectively to respond, adapt and collaborate. Wherein lies the rub: developers are expected to communicate as seamlessly with people as they do with computers, but are rarely given the tools and methodology to do so. Course JAVASCRIPT AND IMPORTANT JAVASCRIPT FRAMEWORKS Sahil Malik JavaScript, the only language that actually runs everywhere. From big servers in the cloud to tiny watches on your wrist. No wonder its gained such popularitly. Spend 5 days with this powerful scripting language, and get up to speed with all the newest web technologies in popular use today. Course SHAREPOINT 2013 AND OFFICE 365: END TO END FOR DEVELOPERS Sahil Malik This course begins with an introduction of SharePoint and Office365, starting with the history, the appropriate usage of the platform, managing a SharePoint based project, and dives deeper into implementation and technical details subsequently. This course covers Office 365 also. Course - 2 Days 1.-2. December IDENTITY & ACCESS CONTROL FOR MODERN WEB APPLICATIONS AND APIS Dominick Baier With ASP.NET MVC, Web API and SignalR

tied together using the new OWIN and Katana framework, Microsoft provides a compelling server-side stack to write modern web applications and services. In this new world we typically want to connect client platforms like iOS, Windows or Android as well as JavaScript-based applications using frameworks like AngularJS. Course OBJECT-ORIENTATED DEVELOPMENT Eivind Nordby Through discussions and a lot of practical training, this course conveys the object-orientated way of thinking, rather than just a programming language. The main target group is developers from non object-orientated languages, like Cobol or C, but also developers using for instance C++ or Java mainly as a stuctured programming language. Course C++ FOR EMBEDDED DEVELOPERS Mike Tarlton This course introduces the C++ language for use on realtime and embedded applications. The first part of the course focuses on the language itself, highlighting areas of concern for real–time and embedded development. The latter part covers the application of C++ to real–time systems including interrupt handling and concurrency issues. If a C++ course does not cover these fundamental issues you may find you still have a lot to learn after the training. Course AGILE SOFTWARE DEVELOPMENT WITH TEAM FOUNDATION SERVER (TFS 2010-TFS 2013) Gáspár Nagy This two-day course prepares software developers, testers and technology-oriented managers to use Microsoft Team Foundation Server for developing agile enterprise applications. The course covers the fundamentals of the core components of TFS, focusing on the Application Lifecycle Management (ALM) aspects that can be used to become a high-performing agile development team.

Course ADVANCED DISTRIBUTED SYSTEMS DESIGN USING SOA & DDD Udi Dahan Designing large–scale distributed systems is hard. New technologies make it easier to comply with today’s communications and security standards, but don’t auto–magically give you a robust and scalable system. Join Udi for a course packed with the wisdom of companies like SUN, Amazon, and EBay. Workshop KOTLIN WORKSHOP Hadi Hariri Kotlin is gaining a lot of traction. Close to release, there are already many companies and individuals that are shipping production code in Kotlin, with some having called it the Swift for Android. Kotlin is a JVM-based language that targets byte code and JavaScript. The design goals are to have a modern, safe, 100% interoperable, fast and concise language, which allows for reducing code bases by around 35%40% and at the same time allowing for complete interoperability with existing code. Course PROGAMMING IN DEEP C Olve Maudal

Course LEAN STARTUP FOR ENTERPRISES Tristian Kromer

BDD - Specification by Example 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 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 23. February 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.

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

HOW TO FIND US PROGRAMUTVIKLING MAIN OFFICE, OSLO Parking Entrance

ProgramUtvikling AS is located in the IT-Fornebu technology park at Snarøya. ADDRESS Martin Lingesvei 17-25, 1367 Snarøya. 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

ENROLMENT OPTIONS Bus stop

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

SINCE 2008

Welcome to NDC in ExCel Arena Docklands, London 1-5 December

Our Inspiring Partners:

@NDC_conferences #ndclondon 54

Get your tickets now!

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

Price

All Access Pass (all 5 days) with hotel* All Access Pass (all 5 days) 3 Day Conference Pass with hotel* 3 Day Conference Pass 2 Day Conference Pass 1 Day Conference Pass

£ 2200 £ 1850 £ 1400 £ 1150 £ 1000 £ 850

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

£ 1000 £ 650

*Hotel packages includes the best available rates at a budget hotel near the venue. 5 nights are covered for the All Access Pass (Sun - Fri) and 3 nights are covered with the 3 day pass (Tue - Fri). 20% VAT will be added to all ticket types.

ndc-london.com 55

THE AGENDA COMMITTEE

NDC London is reaching new hights

The inspiring conference for developers will be held at the ICC suites at the ExCel Exhibiton Centre for the sencond 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

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 ver-

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

LIAM WESTLEY, APPLICATION ARCHITECT AT HUDDLE Liam Westley is an application architect at Huddle based in London, with responsibilities including the mobile application architecture to support their iOS and Android applications. Liam is an active member of the UK .NET community, regularly speaking at user groups and conferences, as well as being an organiser for London .Net Users. A past working in television graphics has left him with a penchant for design and a concern for quality UX.

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.

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.

“Choosing sessions for NDC London 2014 was really tough, but I think we have achieved our goal of reflecting the broad range of skillsets expected from a modern software developer. That end of a single vendor ecosystem is what makes application development a much more interesting discipline.”

"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."

“Both of the number and quality of the Call For Papers have been very high this year. This year NDC London will have 7 parallel tracks. The number of speakers and abstracts shows the position NDC London has as we enter our second year. KJERSTI SANDBERG, GENERAL MANAGER OF PROGRAMUTVIKLING Kjersti Sandberg is the founder of ProgramUtvikling AS and has organized NDC 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. â&#x20AC;&#x153;NDC London is a full week event with PreConference Workshops on 1-2 December followed by the conference days 3-5 December. This year we have added more workshops and conference ticket options, giving our delegates more flexibility to tailor their own NDC experienceâ&#x20AC;?. BRYAN HUNTER, FOUNDER OF NASHVILLE FUNCTIONAL PROGRAMMERS Bryan Hunter is the CTO of Nashvillebased 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 businessleader 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 London. When you see the lineup you will agree he has done very well.

CALL FOR PAPERS FOR NDC OSLO 2015

Call For Papers for NDC Oslo 2015 is now open. You can submit a regular or lightning talk, or even a Pre-Conference or Conference Workshop. We look forward to receiving your submissions.

Submit your talk at

www.ndcoslo.com

"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 for both NDC Oslo and NDC London. I believe that we as an industry are at a tipping point where functional programming becomes mainstream; becomes the norm; becomes the 'safe option'.

2 DAYS OF WORKSHOPS CROWNE PLAZA HOTEL, DOCKLANDS 2 DAYS - 1-2 Dec Udi Dahan Designing loosely-coupled systems Although the development industry has changed technologies repeatedly over the years, countless systems end up devolving into monolithic balls of mud. Join Udi for an in-depth dive into communications patterns like publish/subscribe, correlated one-way request/response, and object-oriented state management practices for long-running workflows. If you enjoy deep architectural discussion and are involved with building a large-scale distributed systems, this is for you.

Denise Jacobs and Jessie Shternshus Agile Innovation New best practices for creative problem-solving, communication, collaboration, and project execution Most development projects rely on the assumption that the environment in which it is built is stable. However, software development environments are highly complex, in constant flux, and thus are unpredictable -- not because of the software itself, but because of the people creating it. A project’s success is dependent upon the team communicating effectively to respond, adapt and collaborate. Wherein lies the rub: developers are expected to communicate as seamlessly with people as they do with computers, but are rarely given the tools and methodology to do so.

Mathias Brandewinder F# via Machine Learning Machine Learning and Functional Programming are both very hot topics these days; they are also both rather intimidating for the beginner. In this workshop, we’ll take a 100% hands-on approach, and learn practical ideas from Machine Learning, by tackling real-world problems and implementing solutions in F#, in a functional style. In the process, you will see that once you get beyond the jargon, F# and Machine Learning are actually not all that complicated - and fit beautifully together. So if you are interested in learning techniques to write smarter programs than learn from data, and sharpening your developer skills, come with your laptop and... let’s hack together!

1 DAY - 1 Dec Sam Newman Design and Implementation of Microservices Microservices Architecture is a concept that aims to decouple a solution by decomposing functionality into discrete services. Microservice architectures can lead to easily changeable, maintainable systems that can be more secure, performant and stable. In this workshop, you will discover a consistent and reinforcing set of tools and practices rooted in the philosophy of small and simple; this can help you move towards a microservice architecture. Microservices are typically small systems, with single responsibilities, communicating via the web’s uniform interface, installed as well-behaved operating system services. However, with these finer-grained systems come new sources of complexity.

@NDC_conferences #ndclondon

You may attend these workshops without going to the conference.

2 DAYS - 1-2 Dec Jeff French Building Cross-Platform Mobile Apps in the Cloud Today mobile applications are a must for almost any business or product. Developing the same application for the major mobile platforms takes a considerable investment in time and learning new technologies. Building out a secure and scalable API for your app can be daunting task. In this workshop we will learn how to leverage existing web-based technologies and skills to develop cross-platform mobile applications backed by scalable REST APIs in a fraction of the time that it takes for native apps. This will be a hands-on workshop where you will be writing a mobile app and RESTful API from scratch.

Venkat Subramaniam Programming in Functional Style “Functional programming,” yes, everyone’s talking about it. But why? What’s this new excitement about something that’s been around for a very long time in some esoteric languages. For one thing, most mainstream languages now support it. C#, Java, C++,... To program in functional style you don’t have to change the language, but you have to change how you program in that language. Change can be hard, but there are some nice rewards that go with it for those of us who are adaptive. Come to this course to learn about the benefits of functional programming and how you can leverage that in the language you program today.

Scott Allen AngularJS workshop AngularJS brings testable architectural patterns to applications built with HTML 5. This course explains and demonstrates the many features of AngularJS, including directives, filters, routing, controllers, templates, services, views. But, the best applications need more than a single framework. We’ll also learn about responsive design, Bootstrap, and the latest HTML 5 features including local storage, the canvas, web workers, web sockets, and more.

Dominick Baier and Brock Allen Identity & Access Control for modern Web Applications and APIs With ASP.NET MVC, Web API and SignalR tied together using the new OWIN and Katana framework, Microsoft provides a compelling server-side stack to write modern web applications and services. In this new world we typically want to connect client platforms like iOS, Windows or Android as well as JavaScript-based applications using frameworks like AngularJS. This two day workshop is your chance to dive into all things security related to these new technologies. Learn how to securely connect native and browser-based applications to your back-ends and integrate them with enterprise identity management systems as well as social identity providers and services.

Workshops are included in the NDC ALL ACCESS CONFERENCE PASS

£2200

Workshop 1 DAY PASS Workshop 2 DAY PASS

£650 £1000

20% VAT will be added to all prices.

ndc-london.com

London is a diverse and exciting city with some of the world’s best sights and attractions. The city attracts more than 30 million visitors from all over the world every year.

By Mari Myhre

With a population of more than 8 million people, London is the most populous region, urban zone and metropolitan city in the United Kingdom. The city has a diverse range of people and cultures, with more than 300 languages are spoken within its boundaries. The city is filled with a thrilling atmosphere and definitely has something to offer for everyone, whether you’re interested in arts, culture, shopping food or entertainment. Here’s a little guide of London’s most famous attractions: BUCKINGHAM PALACE & THE RIVER THAMES Buckingham Palace is by far the most popular tourist destination attracting more than 15 million people every year. People from all over the world come to see the famous “guard change” that takes place outside the palace every day at 11.30am. Many of the city’s other attractions are situated along the banks of the River Thames. Here you will find the Tower of London where tourists can get to see the remarkable Crowns of England. The Houses of Parliament followed by the fabulous clock tower, Big Ben are also in same area. A few blocks away you will find the London Eye, Europe’s tallest Ferris wheel. It’s the most popular paid tourist attraction in the UK visited by more than 3,5 million people every year, where you can get to see the city from above. 60

London THE BOROUGH MARKET London is also well known for its different markets, such as the Borough market, - a wholesale retail and food market based in Southwark, central London. It is one of the largest and oldest food markets in the city and offers a variety of foods from all over the world. The market gives you a different taste of the city and has become a fashionable place to buy fresh food in London. Amongst the products on sale are fresh fruit, vegetables, cheese, meat and freshly baked breads. There is also a wide variety of cooked food and snacks for the many people who flock to the market. Borough Market has also been used as film locations for several movies including the Harry Potter series and Bridget Jones. HYDE PARK Hyde Park is one of the largest parks in the capital, most known for the Speakers Corners. The park has become a traditional location for mass demonstrations, and the venue of several concerts. Hyde Park also hosts the popular Christmas fair Winter Wonderland every year, featuring UK’s largest ice rink, a charming Christmas market and a huge observation wheel. Winter Wonderland is definitely London’s most magical Christmas destination and absolutely worth a visit if you’re in town later this year.

WINE & DINE The city is also packed with exclusive restaurants, which offers you tastes from all over the world. Whether you fancy British, Indian, Italian or Scandinavian, London has it all. The most authentic American restaurant, Big Easy is located in the heart of Chelsea. The founder and owner, Paul Corrett was a lover for all American things and had a desire to open a place that could offer “Good Food, Served Right”. Big Easy brings you back to a simpler time. With its lovely atmosphere it’s the perfect place to sit back, relax and enjoy a home cooked meal. The restaurant offers everything from American steaks to freshly Canadian lobster. Big Easy attracts movie stars, journalists, politicians, the British royal family and of course its regulars. Charming bars and pubs are also located around each corner in London. Princess Louise, a pub based in Holborn is the place to be for beers fanatics. However, if you’re looking for the town’s best cocktails, stop by Callooh Callay in Shoreditch. London is unique compared to other cities and definitely has something new to offer no matter how many times you have visited the city. It’s the perfect destination whether you are in town for business or pleasure. And it’s probably true what the famous English author Samuel Jackson once said, “When you’re tired of London, you’re tired of life”.

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

ea, NDC an intriguing expo ar d an ns io ss se l lle ra ore pa ware developers. tiple choices, even m g experience for soft in ain rt With grand music mul te en d an ng ned to be an inspiri London 2014 is desig

THE TIDE

Find your user group at NDC London London 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 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. Share your knowledge at NDC Community this year.

Having been at NDC before, one simply does not come back just with expectations of great sessions and mingling with peers. You come back expecting a great total experience, with tasty food, fun entertainment and great music as well. NDC London 2014 will not disappoint with its line-up.

SKINNY LISTER

ELOPERS

V A FESTIVAL FOR DE

your average, Skinny Lister are not t ea gr a s ay alw glish folk During NDC there's dern day, gentrified En mo ing en ev ay sd apart folk party mood. On Thur oup. This is a standgr an r fo y ad re t sensitiv4th of December, ge nd- not afraid to match ba rpe e ag st ne g free for all. incredible high-octa ity with a high kickin h ug ro th s ow fl ates and formance, as music e to open the floodg Tim by on nd Lo C arted. the expo area of ND get the deck party st Lister. y inn Sk d an e Tid e Th music perforAll is set for a great st We 's on nd Lo The Tide, based in e at NDC Oslo. l out assault manc â&#x20AC;&#x153;al an e uc od pr d, En es with their on your musical sens t attend NDC. re, unadul- Don't jus pu of y pla dis l rfu we po Experience it! terated rock n'rollâ&#x20AC;?.

ATION CULINARY CELEBR riety of culiAt NDC London a va all day. Move nary food is served and pick up through the expo area of cuisines scents from a variety Asian, Ameriranging from Italian, h. In addition, can, Spanish and Britis rista bar open NDC London keep a ba r you coffee throughout the day, fo loving developers.

PROGRAM – Wednesday .NET Framework Design Gadgets Mobile Testing

Agile Devops Internet Of Things People Tools

Times lots 09:00 - 10:00

Room 1

Room 2

Architecture Front-End Framework JavaScript Programming Languages UX

Room 3

Room 4

Cloud Fun Microsoft Security Web

Room 5

Database Functional Programming Misc Languages Techniques

Room 6

Room 7

TBA Denise Jacobs

10:00 - 10:20

Break

10:20 - 11:20

Coding Culture

Finding Service Boundaries – illustrated in healthcare

Architecting large Single Page Applications with Knockout.js

Sven Peters

Udi Dahan

Steve Sanderson

Abusing C #

Crafting JavaScript Code

TDD All The Things

F-Words - Functional Programming Terms With More Than Four Letters

Jon Skeet

Scott Allen

Liz Keogh

Calvin Bottoms

11:20 - 11:40

Break

11:40 - 12:40

Being an Excellent The experimentaSoftware Developer tion mindset

The Ultimate Logging Architecture - You KNOW You Want It

Asynchronous Programming for .NET Programmers

Chrome Developer Tools Deep Dive

Unit testing patterns for concurrent code

Elixir: a crisp, new language for the Erlang VM

Doc Norton

Michele Leroux Bustamante

Venkat Subramaniam

Shay Friedman

Dror Helper

Bryan Hunter

Doc Norton

12:40 - 13:40

Lunch

13:40 - 14:40

Practical Considera- Capability Red: tions for Requirements at Microservices Scale

Couchbase and ElasticSearch, Sitting in a Tree

Load Testing SignalR

How WPF lost and HTML won - the new wave of crossplatform, hybrid Desktop apps

Lightning talks

Erlang Patterns Matching Business Needs

Sam Newman

Liz Keogh

David Ostrovsky

David Fowler and Damian Edwards

Ian Pender

James Cryer, Harry Cummings, Peter Mounce and Razvan Caliman

Torben Hoffman

14:40 - 15:00

Break

15:00 - 16:00

Commercial Software Development - Writing Software Is Easy, Not Going Bust Is The Hard Bit

The state of state

Core Software Design Principles

Going down the rabbit hole: a case study in corner cases

Modern Style Guides for a Better Tomorrow

Tales of the Equivalence unexpected (a litany Classes, xUnit.net, of test failures) FsCheck, Property-Based Testing

Liam Westley

Rapiro, Bjørn Einar Bjartnes, Jonas Winje and Einar W. Høst

Venkat Subramaniam

Jon Skeet

Shay Howe

Harry Cummings

Mark Seemann

16:00 - 16:20

Break

16:20 - 17:20

My Job Is A Joke Tales Of A Developer Advocate

Not just layers! What can pipelines and events do for you?

Rob Conery Cage Match

Building real time web applications with Node.js and Socket.IO.

Testing Economics 101

TBA

Burke Holland

Ian Cooper

Gary Bernhardt and Rob Conery

Peter O'Hanlon

Gil Zilberfeld

Scott Wlaschin

17:20 - 17:40

Break

17:40 - 18:40

The principles of microservices

Agile 1's game

Lessons Learned on How to select you Cloud Computing Vendor

Learning How to Shape and Configure an OData Feed for High Performing Web Sites and Applications

Client Side MVC != Server Side MVC || Intro to Ember.js

Write Your Own Compiler in 24 Hours

Sam Newman

Seb Rose

Nuno Filipe Godinho

Chris Woodruff

Jeremy Green

Phillip Trelford

PROGRAM – Thursday .NET Framework Design Gadgets Mobile Testing

Times lots 09:00 - 10:00

Agile Devops Internet Of Things People Tools

Room 1

Room 2

Architecture Front-End Framework JavaScript Programming Languages UX

Room 3

Cloud Fun Microsoft Security Web

Room 4

Database Functional Programming Misc Languages Techniques

Room 5

Room 6

Room 7

Self-documenting Code: A Mob Powered Vocabulary Lesson

Databases: the Designing for elephant in the Extensibility Continuous Delivery room

OWIN, Katana and ASP.NET vNext: eliminating the pain of IIS

Epic Web UI Performance with ReactJS.Net

TBA

The F# Way To Reconciliation

Cory House

Enrico Campidoglio

David Simner

Mark Rendle

Andy Wigley

Don Syme

Web Components: The Dawn of the Reusable Web

Is your mobile app as secure as you think?

Mona Lisa, F# and Azure: simple solutions to hard problems

Cory House

Matt Lacey

Miguel A Castro

10:00 - 10:20

Break

10:20 - 11:20

Deliberate advice from an accidental career

Continuous Delivery Writing Compose- An Experience able JavaScript with Report Adaptors and Decorators

Dan North

Chris O'Dell

Reginald Braithwaite

What’s New In C # 6.0?

Scott Allen

Mathias Brandewinder

11:20 - 11:40

Break

11:40 - 12:40

How Constraints Cultivate Growth

Team Foundation Decoupling from Server, Second Look ASP.NET - Hexagonal Architectures in .NET

Unifying ES6: JavaScript, Authentication & grown up Delegated API Access for Mobile, Web and the Desktop with OpenID Connect and OAuth2

Introducing How to think like an NativeScript - All Of Erlanger Your JavaScript Are Belong To Us

Shay Howe

Martin Hinshelwood

Ian Cooper

Dominick Baier

Burke Holland

Jack Franklin

Torben Hoffman

12:40 - 13:40

Break

13:40 - 14:40

Agile Patterns: Estimation

Architecting .NET Applications for Docker and Container Based Deployments

Event Sourcing, Messaging and CQRS Basics

Identity Deception, management in ASP. Responsibility, and NET, Part 1 Duck Punching JavaScript

Developing Mobile Biological Solutions with Computing in F# Azure Mobile Services in Windows 8.1 and Windows Phone

Stephen Forte

Ben Hall

James Nugent

Brock Allen

Chris Woodruff

Todd H Gardner

Mr Colin Gravill

14:40 - 15:00

Break

15:00 - 16:00

Hacking through time Continuous Delivery Data Done Right: 10 and space Done Right! Databases in an Hour

Identity TBA management in ASP. NET, Part 2

Mobile web - mergDistributed Erlang ing responsive and adaptive techniques

Cristiano Beta

Brock Allen

Francisco Manuel da Christopher Silva Ferreira Meiklejohn

Jeff French

David Simons

Gary Bernhardt

16:00 - 16:20

Break

16:20 - 17:20

Conventionally speaking

Embracing DevOps at JUST EAT, within a Microsoft platform

Breaking up a Five (or so) monolith if you don't Essential Things to fancy SOA know about ASP. NET vNext

Everything you need .NET Rocks Live! to know about .NET memory

Jimmy Bogard

Peter Mounce

Helen Emerson

David Fowler and Damian Edwards

Ben Emmett

.NET Rocks!, Carl Kenneth Mackenzie Franklin and Richard Campbell

Kenneth MacKenzie: SD Erlang Release

17:20 - 17:40

Break

17:40 - 18:40

The three questions about your career that matter

Adopting Continuous Delivery: Adjusting your Architecture

Security WTF!

"Write once, run anywhere”: Can AngularJS & Cordova do it?

Lightning talks

ES6 and 7, the future of JS

Simpler Data Access and Smarter Calculations

Reginald Braithwaite

Rachel Laycock

Niall Merrigan

Christian Weyer

Ed Blackburn, Razvan Caliman, Rafał Legiędź, Michał Śliwoń and Todd H Gardner

Brendan Eich

Paul Blasucci

18:40 - 00:00

The NDC Party 65

PROGRAM – Friday .NET Framework Design Gadgets Mobile Testing

Agile Devops Internet Of Things People Tools

Time slots 09:00 - 10:00

Room 1

Room 3

Room 4

Cloud Fun Microsoft Security Web

Room 5

Database Functional Programming Misc Languages Techniques

Room 6

Room 7

Advanced TDD: Writing Clean Tests

Hypermedia in the Wizard's Tower

How to Save the World Without Wearing Your Underpants on the Outside.

TBA

Beyond Rectangles in Web Design: CSS Shapes and CSS Masking

Unpacking Technical From C # to Haskell Decisions

Robert C. Martin

Einar W. Høst

Gary Short

TBA

Razvan Caliman

Sarah Mei

Louis Salin

How to create a Web An Introduction to API no one wants to Artifi cial use Intelligence

Getting up to speed with redis

AngularJS for ASP. NET MVC Developers

Kicking the complexity habit

My adventure with Elm

Karoline Klever

Seth Juarez

Marc Gravell

Miguel A Castro

Dan North

Yan Cui

10:00 - 10:20

Break

10:20 - 11:20

Agile

Stephen Forte and Richard Campbell

Room 2

Architecture Front-End Framework JavaScript Programming Languages UX

11:20 - 11:40

Break

11:40 - 12:40

Building Natural User Interface applications with Intel RealSense.

asm.js, SIMD, and JS as a compiledlanguage virtual machine

Principles of Modern Data Visualization

ASP.NET Web API: Beyond the Basics

It’s the top 10 of cool HTML5 features every developer should know right now

Making Steaks from Sacred Cows

TBA

Peter O'Hanlon

Brendan Eich

Seth Juarez

Ido Flatow

Gill Cleeren

Kevlin Henney

Scott Wlaschin

12:40 - 13:40

Lunch

13:40 - 14:40

A fragile internet of things

TBA

Tracking Real World Web Performance

Resilient Architectures for the cloud

Reactive, Event Driven User Interfaces

Thinking outside the TBA DOM

Erlend Oftedal

Rob Conery

Nik Molnar

Mahesh Krishnan

Ray Booysen

Christian Johansen

Andrea Magnorsky

14:40 - 15:00

Break

15:00 - 16:00

Project Orleans: Gesture building the internet Recognition with of things Kinect for Windows

Data Science for Fun and Profi t

TBA

REST easy

The Architecture of Uncertainty

The Great @fsibot Caper

Richard Astbury

Carl Franklin

Gary Short

Andy Wigley

Jimmy Bogard

Kevlin Henney

Mathias Brandewinder

16:00 - 16:20

Break

16:20 - 17:20

The Dos and Don'ts of Multithreaded Programming

Performance is a Feature!

When the connection fails - Developing ofﬂ ine mobile applications

TBA

Separating Allocation from Code: a journey of discovery

One frontend, one backend, three mobile platforms

Polyglot heaven - how to build an async, reactive application in 2014

Hubert Matthews

Matt Warren

Barbara Fusińska

TBA

Chris Parsons

Richard Garside

Tomas Jansson

NDC People

Create better together 5. February Radisson Blu Scandinavia Oslo

people.ndcevents.com

DON’T LET ANOTHER YEAR GO BY WHERE YOUR TEAM DOESN’T REACH ITS POTENTIAL! NDC is proud to present Create Better Together, an inspirational day of talks and workshops focused on building more effective development teams. Too often the intentions of a team are aligned but unintended actions derail everything. The culprit? Poor communication. AT THE EVENT YOU’LL LEARN: * What it takes both as individuals and teams to work better together * How to unblock yourself when you hit mental walls * Ways in which we can unintentionally impact each other through our moods and actions * Tips and tricks on keeping the team focused and aligned * Overcoming unique situations developers face * A human centered approach to accomplishing goals * Creative ways to make problem solving fun! Don’t miss this chance to kick 2015 off right, sign up today for Create Better Together!

HERE'S OUR AMAZING SPEAKERS

DENISE JACOBS

The Creative Dose Founder + Chief Creativity Evangelist

JESSIE SHTERNSHUS The IMPROV EFFECT

CARL SMITH nGen Works The Advisor

MICHAEL “DOC” NORTON Groupon

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!