ndc magazine- ndc oslo 2015 edition

Attack Attribution and the Future of International

Cyber ConflictBRUCE SCHNEIER

BIG SCRUM: ARE YOU DOING

MECHANICAL SCRUM?

Martin Hinshelwood

AZURE IS DEADLONG LIVE AZURE Chris Klug andRobert Folkesson

THE ELASTIC FAMILY: BIG DATA SEARCH, DISCOVERY AND ANALYTICS Christoffer Vig

CLUTTER-FREE PROGRAMMING

John Azariah

INTRODUCING THE TESTING

ICEBERGSeb Rose

www.ndcmagazine.com

NDC OSLOConference, 17.-19. JunePre-workshops, 15.-16. June

NDC OSLO ISSUE

NO 1/2015

MAGAZINE FOR SOFTWARE DEVELOPERS AND LEADERS

THE DEVELOPER


Cyber ConflictBRUCE SCHNEIER

© G

eoff

rey

Sto

ne

2

2014 was the year of the security breach. Systems were found to be leaking more information than ever before coupled with some long standing bugs that were revealed in spectacular fashion. In addition, the leaks are only getting bigger as more and more systems become

interconnected and available on the internet especially with the explo-sion of IoT devices into the market. This year is the year of the fight-back. This year we will arm our developers with the ski l ls to defend their carefully crafted software from those who would like to exploit it. As part of NDC Oslo 2015, we have increased the emphasis on security with some of the biggest names in the industry coming to Oslo to share their wisdom and give you some insights into their techniques. 2015 has also seen the rise of newer JavaScript frameworks and the decline of others. Such is the flux of our fast changing indus-try. We are beginning to see the frameworks evolve more rapidly

driven partly by innovation and partly because of Open Source. Even the traditionalists are embrac-ing Open Source for what it pro-vides which is a truly collaborative coding and learning experience with the production of exceptional amounts of code by crowd sourc-ing of the problems. It was exceptionally challenging and fun to help build the agenda for NDC Oslo 2015. This year, we hope that you have as broad a learning experience as possible with the plethora of sessions that are available to you. Most impor-tantly, we want you to go home armed to the teeth with new tech-niques and ideas that you will learn from your peers in this constantly changing industry!

Time to step up and defendyour data and applications

by Niall Merrigan

NDC Magazine 1-2015

NO

RDIC ECOLABEL

241 Printing company

672

Member of Den Norske Fagpresses Forening

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

Print run: 11,000 Print: Artko

Editor: Kjersti Sandberg

Marketing Manager: Charlotte Lyng

3© N

ik M

erku

lov/

Shu

tter

stoc

k

Contentsby Niall MerrixxxxARTICLESAttack Attribution and the Future of

International Cyber Conflict ................................................ p. 4

From Developer to Devpreneur ....................................... p. 8

Introducing the Testing Iceberg ..................................... p. 10

Azure is dead. Long live Azure ....................................... p. 12

Thinking rationally about the database problem ..p. 16

The Elastic family:Big data search,

discovery and analytics ...................................................... p. 20

The omni-presence of Windows 10 ........................... p. 24

Big Scrum: Are you doing mechanical Scrum? ... p. 28

Applications to Apps backed by the Cloud ........... p. 32

Objects as state machines ............................................... p. 34

Hybrid Mobile Development

with the Ionic Framework ................................................. p. 38

Resolving Conflicts in Occasionally

Connected Mobile Apps .................................................... p. 44

Analyzing thousands of dump files

from production systems ................................................. p. 48

The emergent nature of software architecture . p. 50

Static websites are good for your health .............. p. 56

Clutter-Free Programming ................................................ p. 58

Courses from ProgramUtvikling .................................. p. 64

NDC 2015The NDC Oslo Team ............................................................. p. 70

Meet the user groups at NDC community .......... p. 74

Programming – the most important language

of the information age ......................................................... p. 76

Oslo - The capital of Norway ........................................... p. 78

Program Wednesday - Friday .......................................... p. 80

4

© L

ollo

j/Shu

tter

stoc

k

5

What’s both amazing – and per-haps a bit frightening – about that dispute over who hacked Sony is that it happened in the first place.

But what it highlights is the fact that we’re living in a world where we can’t easily tell the differ-ence between a couple of guys in a basement apartment and the North Korean government with an estimated $10 billion military budget. And that ambiguity has profound implications for how countries will conduct foreign pol-icy in the Internet age.

Clandestine military operations aren’t new. Terrorism can be hard to attribute, especially the murky edges of state-sponsored terror-ism. What’s different in cyberspace is how easy it is for an attacker to mask his identity – and the wide variety of people and institutions that can attack anonymously.

In the real world, you can often identify the attacker by the weap-onry. In 2006, Israel attacked a Syrian nuclear facility. It was a con-ventional attack – military airplanes flew over Syria and bombed the plant – and there was never any doubt who did it. That shorthand doesn’t work in cyberspace.

When the US and Israel attacked an Iranian nuclear facility in 2010, they used a cyberweapon and their involvement was a secret for years. On the Internet, technol-ogy broadly disseminates capa-bility. Everyone from lone hack-ers to criminals to hypothetical cyberterrorists to nations’ spies and soldiers are using the same tools and the same tactics. Inter-net traffic doesn’t come with a return address, and it’s easy for an attacker to obscure his tracks by routing his attacks through some innocent third party.

And while it now seems that North Korea did indeed attack Sony, the attack it most resem-bles was conducted by members of the hacker group Anonymous against a company called HBGary Federal in 2011. In the same year, other members of Anonymous threatened NATO, and in 2014, still others announced that they were going to attack ISIS. Regardless of what you think of the group’s capabilities, it’s a new world when a bunch of hackers can threaten an international military alliance.

Even when a victim does manage to attribute a cyberattack, the process can take a long time. It took the US weeks to publicly blame North Korea for the Sony attacks. That was relatively fast; most of that time was probably spent trying to figure out how to respond. Attacks by China against US companies have taken much longer to attribute.


Cyber Conflictby Bruce Schneier

The vigorous debate after the Sony Pictures breach pitted the Obamaadministrationmagainst many of us in the cybersecurity community who didn’t buy

Washington’s claim that North Korea was the culprit.

6

This delay makes defense policy difficult. Microsoft’s Scott Char-ney makes this point: When you’re being physically attacked, you can call on a variety of organizations to defend you – the police, the mili-tary, whoever does antiterrorism security in your country, your law-yers. The legal structure justifying that defense depends on knowing two things: who’s attacking you, and why. Unfortunately, when you’re being attacked in cyber-space, the two things you often don’t know are who’s attacking you, and why.

Whose job was it to defend Sony? Was it the US military’s, because it believed the attack to have come from North Korea? Was it the FBI, because this wasn’t an act of war? Was it Sony’s own problem, because it’s a private company? What about during those first weeks, when no one knew who the attacker was? These are just a few of the policy questions that we don’t have good answers for.

Certainly Sony needs enough security to protect itself regard-less of who the attacker was, as do all of us. For the victim of a cyberattack, who the attacker is can be academic. The damage is the same, whether it’s a couple of hackers or a nation-state.

In the geopolitical realm, though, attribution is vital. And not only is attribution hard, providing evi-dence of any attribution is even harder. Because so much of the FBI’s evidence was classified – and probably provided by the National Security Agency – it was not able to explain why it was so sure North Korea did it. As I recently wrote: “The agency might have intelli-gence on the planning process for the hack. It might, say, have phone calls discussing the project, weekly PowerPoint status reports, or even Kim Jong-un’s sign-off on the plan.” Making any of this public would reveal the NSA’s “sources and methods,” something it regards as a very important secret.

Different types of attribution require different levels of evidence. In the Sony case, we saw the US government was able to gener-ate enough evidence to convince itself. Perhaps it had the additional evidence required to convince North Korea it was sure, and pro-vided that over diplomatic chan-nels. But if the public is expected to support any government retalia-tory action, they are going to need sufficient evidence made public to convince them. Today, trust in US intelligence agencies is low, espe-cially after the 2003 Iraqi weap-ons-of-mass-destruction debacle.

What all of this means is that we are in the middle of an arms race between attackers and those that want to identify them: deception and deception detection. It’s an arms race in which the US – and, by extension, its allies – has a sin-gular advantage. We spend more money on electronic eavesdrop-ping than the rest of the world combined, we have more tech-

© L

ollo

j/Shu

tter

stoc

k

7

nology companies than any other country, and the architecture of the Internet ensures that most of the world’s traffic passes through net-works the NSA can eavesdrop on.

In 2012, then US Secretary of Defense Leon Panetta said publicly that the US -- presumably the NSA – has “made significant advances in ... identifying the origins” of cyberattacks. We don’t know if this means they have made some fun-damental technological advance, or that their espionage is so good that they’re monitoring the planning pro-cesses. Other US government offi-cials have privately said that they’ve solved the attribution problem.

We don’t know how much of that is real and how much is bluster. It’s actually in America’s best inter-est to confidently accuse North Korea, even if it isn’t sure, because it sends a strong message to the rest of the world: “Don’t think you can hide in cyberspace. If you try anything, we’ll know it’s you.”

Strong attribution leads to deter-rence. The detailed NSA capabil-ities leaked by Edward Snowden help with this, because they bolster an image of an almost-omniscient NSA.

It’s not, though – which brings us back to the arms race. A world where hackers and governments have the same capabilities, where governments can masquerade as hackers or as other governments, and where much of the attribution evidence intelligence agencies col-lect remains secret, is a dangerous place.

So is a world where countries have secret capabilities for deception and detection deception, and are constantly trying to get the best of each other. This is the world of today, though, and we need to be prepared for it.

Bruce Schneier, CTO of Resilient Systems Inc., is an internationally renowned security technologist, called a “security guru” by The Economist. He is the author of 13 books, as well as hundreds of articles, essays, and academic papers. His blog “Schneier on Security”, https://www.schneier.com/, is read by over 250,000 people. He has testified before Congress, is a frequent guest on television and radio, has served on several government commit-tees, and is regularly quoted in the press.

8

From Developer to Devpreneur

by Alan Mendelevich

The advent of app stores empowered individual developers and small teams once again.We feel that we can make our own products again and don’t need huge budgets to do that.

We know how to write good, manageable code. We may even know how to design a good product. And we believe that we will build it and users will come.

© V

ikpi

t/S

hutt

erst

ock

9

THE ROAD TO APP STORE SUCCESSUnfortunately, research shows that in most cases the quality of the product itself is just 20% of its success and the remaining 80% is marketing. Well…. I totally made these numbers up, but it doesn’t make the statement false. With literally millions of apps in the app stores, expecting users to stumble on your great app is naïve at best.

So if you are embarking on the app entrepreneur jour-ney you should definitely dedicate a sizeable chunk of your time to activities other than design and coding.

While most developers understand this on a logical level, over the years I’ve seen a lot of frustration which I can attribute to the fact that most of the developers – even those working as contractors and freelancers – just aren’t wired this way.

DEVELOPER’S WORK CYCLEAt the high level the business process of every em ploy ed developer or those running their own consulting busi-nesses looks something like this:

We get the task (either in a form of project or position in a company), we deliver what’s expected of us (com-pleted project or a part of it) and we get paid. When we switch to the app entrepreneur world the overall process looks pretty much the same: our app idea is the task, completed app – a deliverable and the app store brings us money. But there’s one major difference, though.

As employee or contract developers we are used to doing all of our sales activities before we even get started:

We go to job interviews or prospective client meet-ings and we try to sell our skills. At that stage we’ve only made a minor investment into the “project” ranging from a couple of hours to a couple of days of our time. Failed a job interview? Sad, but not a big deal. On to the next opportunity.

Everything changes when you are an entrepreneur. You have to decide if your idea is commercially viable and most of the times there’s no sure way to deter-mine this. So you have to decide to invest a signifi-

cant chunk of your time (and money) into a task with a lot of uncertainty.

This is just common sense and every developer understands this. Having said that, we are still inter-nally wired to consider delivery of the completed product as our final destination. We pop the cham-pagne the minute the app goes live in the store. And we get depressed when we don’t see the immediate monetary return as per the scheme above.

The reality is that app’s publication is just the begin-ning of our sales activities and you have to work on your sales and marketing for the complete lifetime of your app.

The difference is subtle and huge at the same time. I see depressed developers-turned-app-entrepre-neurs over and over again. And it’s not the quality of their app that’s at fault. Sometimes it’s the fact that they’ve decided to implement commercially unsound idea. But more often than not, even with great prod-uct-market fit, the cause of the disappointment is imagining a finish line in the middle of the marathon.

“My app is done” doesn’t mean that you’ve finished coding it. Your app is only done when you stop sup-porting it and unpublish it from the store. Otherwise you are still working on it.

Alan Mendelevich has been developing software for a living for more than 15 years. In early 2011 Alan launched AdDuplex – a cross-promotion network for Windows apps. He is happy to share the insights back with the community on his blog at http://blog.ailon.org, twitter @ailon and talks on the subjects of app development, marketing and monetization.

Introducing the Testing Iceberg

by Seb Rose

© L

uis

Lour

o/S

hutt

erst

ock

1 1

Mike Cohn popularised the Testing Pyramid in his book “Succeeding with agile.” [http://www.mountain-goatsoftware.com/books/succeeding-with-agile-soft-ware-development-using-scrum] The message it tries to convey is that the foundation of quality code is lots of small, fast, “unit” tests. As you begin to test larger components, you should be writing fewer tests. Then, finally, you should have even fewer end-to-end tests that exercise the whole application. There has been plenty of discussion about what exactly a “unit” is, but let’s sidestep that and simply say that “the more of the application a test exercises, the fewer tests there should be.”

Then, when teams discover Specification By Example (SBE) and Behaviour Driven Development (BDD), they have to decide which tests to express in the business domain language (using Cucumber, SpecFlow, FIT etc.), and which to leave in the implementation lan-guage (using Java/JUnit, C#/MsTest etc.) A simplis-tic approach that is often adopted is to draw a line across the Testing Pyramid and express end-to-end, system tests in business domain language, that can be read by non-technical team members, and all nar-rower tests in a form that can only be read by those with programming skills. This misses the fundamental reason for describing the behaviour of the system in business domain language in the first place - which is to facilitate collaboration between technical and non-technical people. By providing a place to express, in an accessible format, all system behaviours that are of interest to the customer or product owner, we close the feedback loop between the request for functionality (“this is what I want”) and the certainty that the request has been understood (“this is what we will deliver”). It’s at this point that the extra effort of automating the examples (that demonstrate the system behaves in the way expected) starts to deliver value.

The question that arises in many teams while adopt-ing this way of working is “when should we use a BDD tool and when a unit testing tool?” Often, the

behaviours that are of interest to business people will be expressed in terms of end-to-end interactions with the system, but not always. Actuaries in an insurance company, for example, may well expect to see exam-ples of complex calculations expressed in the busi-ness domain language, without needing to consider the users interaction with the system. Conversely, the development team may want to run many end-to-end user journeys to investigate performance under load, but will be happier expressing this in the implemen-tation language of their choice, and there is little ben-efit from making these investigations readable by the business.

This seeming contradiction led Matt Wynne and I to draw the Testing Iceberg [http://claysnow.co.uk/the-testing-iceberg/], which is just the Testing Pyramid skewed sideways. The Readability Waterline clearly communicates that the choice of how to express a behaviour should be governed by whether it is of interest to business people or not. This decision is orthogonal to the depth of the application stack that needs to be exercised to demonstrate the behaviour of the system.

Consultant, coach, designer, analyst and developer for over 30 years. Regular speaker at conferences and occasional contributor to software jour-nals. Contributing author to “97 Things Every Programmer Should Know” (O’Reilly) and lead author of “The Cucumber for Java Book” (Pragmatic Programmers). He blogs at claysnow.co.uk and tweets as @sebrose.

1 2

© T

shirt

Des

igns

/Shu

tter

stoc

k

1 3

IN THE BEGINNING THERE WAS…PLATFORM AS A SERVICEWhen Microsoft legend Dave Cut-ler, maybe most famous for the development of the Windows NT operating system – the very origin of the modern Windows OS, began working on a new cloud operating system, few understood how for-ward thinking the result would be. In 2008 Microsoft announced something that was very different from what most Microsoft cus-tomers thought of as cloud ser-vices. Back then, cloud services, for traditional IT-shops, mostly meant either the hosting of virtual machines, ala Rackspace, or web based mail and CRM, ala Sales-force. The latter even having “No Software” as its slogan. The new Windows Azure cloud services on the other hand were very much about software. More specifically about your code being packaged and uploaded to the Microsoft cloud, handled by Cutlers “fabric controller”, and hosted in the Micro-soft Datacenter. The new term for this - Platform as a Service, or PaaS, - was being trumpeted out of Redmond. The market however, was clearly not yet ready for it, and a lot of customers voiced the need to be able to host their own virtual machines in Azure.

THE NEW OLD SCHOOLMicrosoft, arguably late to the game with Infrastructure as a Ser-vice (IaaS), waited until July 2012 to finally let its IaaS offering into General Availability, after a longer period of preview.

With this move, Microsoft also took another very important step on its new road to openness. It was now possible to run Linux distributions in Azure. With the IaaS offering, Microsoft opened up some really important scenarios: the “lift and shift”; moving your old legacy system more or less “as is” into the cloud, and the realiza-tion of the “dynamic datacenter” vision; being able to move your vir-tual machines seamlessly between on premise and the cloud. It also made the very interesting Paas/IaaS hybrid scenario possible, using PaaS as much as the plat-form would allow, and falling back to virtual machines when needed (for example running SQL Server Reporting Services, a service Microsoft to some grief removed as a PaaS service in 2014).

PAAS DONE RIGHT?Having virtual infrastructure hosted by someone else may be useful in a lot of ways, but the real power

of the cloud lies in PaaS. Using PaaS, we leave even more of the day-to-day management to some-one else, and focus more on the application development than the operations.

Microsoft’s first PaaS offering was based around web- and worker roles; a fairly crude way of host-ing applications in a semi platform agnostic way. It worked well, but required the developer to take into account that it was a PaaS hosted service. It wasn’t just “build-and-deploy”, like PaaS should be if done right.

Fast forward a couple of years, and Microsoft changes the game by introducing a new PaaS offer-ing called Azure Website; a much simpler platform that pretty much offers “build-and-deploy”; letting developers more or less ignore the platform it would run on. It is “just an application” that is being hosted somewhere. Initially, most devel-opers saw it as a perfect fit for simple websites that just needed a host somewhere. Just build your application, press deploy, and all of the sudden it was hosted in the cloud. And if you needed to scale out, just pull a lever and it is done.

Azure is deadLong live Azure

by Chris Klug and Robert Folkesson

14

However, it still felt like an offer-ing for simpler websites. At least until Microsoft decided to add sup-port for other platforms like Node.js, PHP, Java etc., and support for simple continuous integration and delivery through services like GitHub, Bitbucket and Visual Studio Online. And if you needed to exe-cute code outside your web app, then the introduction of WebJobs solved that. All of the sudden, it didn’t look like the web roles’ lit-tle sister. Instead it started to look like the best way to host things in Azure. It started to look like PaaS done right.

THE SERVICE EXPLOSIONThe last couple of years, the devel-opment of the Azure platform seems do have gone into crazy warp speed overdrive. It is no coin-cidence this happens after some of the more well-known Microsoft luminaries like Scott Guthrie and Mark Russinovich joins the Azure teams, and if anything it proves Microsoft commitment to the platform. Now, it’s all about new services being rolled out and old services being revised in a speed that makes it a tough job to keep up with. The launch of Mobile Services for the efficient develop-ment of backend API: s, the Biz-Talk services with its integration points, the API management plat-form, plus the existing Web Site goodness – all now rolled into one “super-PaaS” offering in the form of Azure App Service.

GOING FORWARDThe future for the Azure platform will without a doubt continue to be a fast paced journey accompa-nied by some really strong industry trends. The Devops revolution will continue to gain traction, and we will see an even deeper integration with the Release Management tools. Micro services will become an increasingly popular architec-tural style for solutions built on Azure, backed by the App Service platform, or just using the various services that exists in the plat-form. The advent of Big Data, and Machine Learning for the masses, is just starting to become a reality, an area where we will probably see an explosion of applications in the near future. Last but not least – Microsoft is really delivering on its promise of making Azure an open platform – gone are the days when forcing us to use a single operating system, or a single developer envi-ronment, was on the top of priori-ties from Redmond. On the surface, only parts of the Azure that was announced in 2008 remain, and probably not much is the same beneath it. But look-ing back, that really isn’t a terrible thing. So there is just one thing left to do, buckle up and enjoy the ride.

Chris Klug is a senior developer and architect at Active Solution in Stockholm; an Azure loving web developer, and kiteboarder, who has been working on Azure based applications since the beginning of Azure, and with Microsoft technology for the last 15 years or so.

Robert Folkesson has been involved in various forms of Internet-related development and distributed systems design for over fifteen years. He currently holds a position as CTO at the Swedish developer consultant and Azure special-ist company Active Solution. Robert is a frequent speaker at conferences, like TechDays, ScanDev and DevSum. He is also one of the editors and co-authors of the “The IT-archi-tecture book”, a unique collabo-ration on modern methods in IT architecture. atlassian.com

atlassian.com

1 6

All the books about software development point in the same direction: Proper source code man-agement, continuous integration, continuous delivery, frequent iter-ations and frequent releases are all good things.

But doing that for databases is hard.

“If it’s hard do it often!”

But relational databases are really, really hard.

So where does that leave us?

Well, essentially there are two classes of solutions. At their core

they are quite simple actually, but neither are perfect – and people get really passionate about one or the other being the *only* way to do databases right. If anyone tells you there is only one way to do something they are probably mis-taken or they are trying to sell you something.

WHY ALL THE FUSS?WHY CAN’T WE CHOOSE RATIONALLY?Despite what we claim, humans are terrible at making decisions based on data. We are social/emo-tional beings and we form opinions and make decisions based on our own experience, and the amount of experiences most of us have

had do not equate to statistical sig-nificance. Also our emotions lead us to stronger and more irrational conclusions than the raw data would justify.

So people think about what they tried before and decide that clearly that way did not work – so the other solution must be the better one. The grass is always greener right? “I tried doing it one way and it burned my face off so I’m never going to do that again.”

Hence, strong and polarised opin-ions are born – often among the people we consider to be bat-tle-worn and experienced.

Thinking rationally about the database problem

by Alex Yates

I get it – databases are hard.

© M

arce

l Cle

men

s - 3

D/S

hutt

erst

ock

1 7

THE FUNDAMENTAL REASON RELATIONAL DATABASES ARE HARDFrankly, people may struggle with either type of solution because databases are just hard. With most code you define how the code should look. When you deploy it you can simply replace the old code with the new code and you’re done. This means it is relatively easy to version control your code, to test the code and to deploy it consistently.

With databases you need to worry about persistence. If you simply replace the old database schema with the new one you just lost all the data. So you need to worry not only about how the state should look, but also about what code you need to run to get from one state to the other. That’s twice as much work, so you are twice as exposed to errors – and failed deployments are a nasty busi-ness. Let’s look briefly at the two classes of solutions.

MIGRATIONS BASEDSOLUTIONSSave a base image of your data-base schema and then add sequen-tial scripts to apply updates to it. It’s relatively straightforward to run the scripts in order to update the production database to the latest version. Some people also write downgrade scripts so that they can roll-back. With this approach you get complete control of how every update will be handled, which brings great power and great responsibility. However, with the power and apparent simplicity come problems:• You have to enforce a very strict

process upon all of your develop-ers. (And we all know developers love that!)

• If you want to work out the difference between version X and version Y you may need to review every line of every script in between – finding a bug can be like looking for a needle in a haystack. And then working out how to apply the fix to your source code is non-trivial.

• An upgrade script is only reliable when you know the exact start and end point. When you merge branches or someone modifies the production environment out-side your process, well, you have problems. Sometimes inconsist-encies on the production environ-ment go unnoticed for months, undermining testing efforts on different environments.

• If your database is a dependency for more than one project or team, which one is responsible for the migration scripts? If more than one, how is the sequence controlled?

STATE/DECLARATIVE BASED SOLUTIONSKeep track of how you want the database to look in source control, rather than the upgrade path. This way you are able to work on the actual database rather than scripts and tools can be used to automate the source control process and provide consistency. This can give you confidence that the code you work with in dev and test will be in sync with what you deploy to pro-duction, in keeping with CI and CD principles, and it’s far less complex and time-consuming than creating all migrations scripts manually.

However, the benefits of this approach raise other questions:• Simply diffing vX and vY is rel-

atively simple with a basic diff tool, but scripting out those changes will either be manual or you will need to purchase a tool to automate this for you… and then you need to test the upgrade script sufficiently that you trust it.

• You may have less control of how your deployments are scripted out so you may need to inter vene with automated pro-cesses when refactoring tables etc. But, on the other hand, many tools now offer specific mechanisms to address this known complexity.

• If someone makes an important fix directly on the production database the fix might acciden-tally get rolled back if it is not also made in source control.

SO WHICH APPROACH ISBETTER?Actually, I can’t say. If only things were that simple. Essentially, it depends on your project, the tech-nologies you use and the people in your team/at your organisation.

On balance, if you are a small team and you know the production data-base never changes and you want more control over exactly how the database will be updated you may prefer the migrations approach. If multiple teams, projects or appli-cations are touching the same database and/or you want an eas-ier, more scalable process and to ensure consistency and reduce the risk of human error you may want to use a state based approach.

But this is a much bigger discus-sion than a short article can really give justice to. All I ask is that we stop writing off solutions (on either side) just because we had some bad experiences with them histori-cally. Whichever way you decide to go, databases are hard (did I men-tion that?) so you should never expect either approach to solve all the problems.

If you’d like to discuss your data-base issues in more detail tweet me: @_AlexYates_. I’ll be around for the whole of NDC Oslo and I’ll be talking about continuous deliv-ery and databases in room 1 at 4.20pm on Thursday.

Alex works for Redgate to help teams improve their Database Lifecycle Management pro-cesses. Since 2010 he’s worked with hundreds of teams, large and small, across all major industry sectors and on all the world’s continents (except Antarctica - to date) to solve similar problem.He blogs about the patterns he notices: www.workingwithdevs.com

Ticket types Price 2 Day Pre-Conference Workshop Pass NOK 10500 1 Day Pre-Conference Workshop Pass NOK 8900 25% VAT will be added to all ticket types.

be inspiredsign up now!

2 DAYS OF WORKSHOPS AT ROYAL CHRISTIANIA HOTEL

You may attend these workshops without going to the conference

Sam NewmanDesign and Implementation of Microservices15 June

Jimmy BogardNServiceBus Crash Course15 June

Jon Galloway / Damian EdwardsWhat’s new in ASP.NET 5 and MVC 6?

Dominick Baier / Brock AllenIdentity & Access Control for modern Web Applications and APIs

Suz HintonJavaScript Robotics - building and coding electronics with NodeJS15 June

Nicolai JosuttisSwitching to C++11/C++14 «by Example»

Scott AllenAngularJS workshop

Troy HuntHack Yourself First: How to go on the Cyber-Offence

James GrenningTest-Driven Development for C or C++ Training

Venkat SubramaniamFunctional Programming 15 June

Venkat SubramaniamFunctional Programming 16 June

Uffe Björklund Bluetooth Low Energy, RealTime Communication & Protocols16 June

Gojko AdzicHow to get more value out of User Stories16 June

Udi DahanDesigning loosely-coupled systems16 June

ONE DAY

TWO DAYS - 15-16 JUNE

Sam NewmanContinuous Delivery16 June

ndcoslo.com@NDC_conferences #ndcoslo

Workshops are included in the

NDC ALL ACCESS CONFERENCE PASS

NOK 1890025% VAT will be added

Michele Bustamante / Lynn LangitAWS vs. Azure15 June

20

The information revolution creates new opportunities for learning from big data each day. Elastic, the company previously known as Elasticsearch, is moving closer to what in practical terms is the data space with every new version. We see this in the development of the ELK stack; Elasticsearch, Logstash and Kibana, a family of products made for big data search, discov-ery and analytics.

ELASTICSEARCHWhen Shay Banon started playing around with “new age” search tools back in 2004, he was trying to figure out ways to help out his newly-wed-chef-to-be with rec-

ipe search. He didn’t quite expect that his experiments would 10 years later be the platform used to analyze the operations of a robot exploring the planet Mars. Yet, this was exactly what was pre-sented by two chaps from NASA at this year’s Elastic{ON} confer-ence. Elasticsearch wasn’t the first search engine Shay Banon wrote. In 2004 he created Compass, with the intention of putting the power of search into the hands of devel-opers. You could create custom objects, stuff them into the index by using a simple interface and voilá: search them. No need for complex configurations upfront, search was instantly available.

Compass was built upon Lucene, which provided sol id founda-tions for search functionality, and became a quite popular project. However, Compass failed to scale to larger amounts of data, and to address this, Shay embarked upon a new project, focusing right from the start on distributed scalability while retaining the core values of developer usability from Compass.This is the Elasticsearch we know today, a RESTful, distributed and scalable search engine. It has excellent client language support (javascript, C#, python…) and scales to monstrous dimensions, as was demonstrated at Elastic{ON} by users such as GitHub, Verizon,

The Elastic family:Big data search,

discoveryand analytics

by Christoffer Vig

As the Ancient greek philosopher Heraclitus (525 BCE) used to say: “an abundance of datadoes not automatically create insights” (DK frag. 40, my own slightly modernized translation).

Data in itself carries no value. Wisdom starts from wonder, wonder feeds questions andquestioning data yields knowledge and perhaps wisdom.

2 1

Microsoft, Netflix and Goldman Sachs. One of the most common use cases for Elasticsearch is log aggregation and analytics, often done by utilizing the full ELK stack. In the following sections I will briefly explain how these products fit together to make the ultimate search, analytics and discovery platform.

LOGSTASHLogging is a central piece of infra-structure in most information sys-tems. In this context we consider logging a stream of discrete pieces of information about events, with a timestamp and associated data. Many systems produce logs in common formats, and Logstash supports many of these out of the box. For custom formats Logstash supplies a flexible toolset com-plete with regular expressions that can extract structured data from raw text. Logstash started out

as a general log processing tool, using three configurable stages; input, filter and output. The input stage is responsible for access-ing the log source itself. The most common and obvious of the input stages is perhaps the file input, which reads logs stored in files. There are many others, tcp, twit-ter, syslog, etc. After reading the logs, the filter stage is used to modify the log event, extracting fields, typically formatting dates into a common format. Finally, the output stage sends results off to some database or search engine. Logstash was initially developed independently to Elasticsearch, but was later absorbed into the Elasticsearch ecosystem. Future developments will make it an even more central tool, adding improved automation and resiliency. Now with the river plugins being dep-recated it is reason to believe log-stash will move into a general data

ingestion framework, not only for time stamped data.

KIBANAKibana is the frontend component of the ELK analytics stack. Kibana runs on top of Elasticsearch, and was recently released in version 4. It is a complete rewrite from ver-sion 3, adding support for complex aggregations. The Kibana app has three tabs: Discover, Visualize and Dashboard.

© A

rthi

med

es/S

hutt

erst

ock

22

Discover is where you search and investigate the raw data as text, allowing drill downs and searches by clicking on search results and field names. Selecting fields to show in search results displays quick summaries of field contents. You can save and share searches or use them as building blocks for visualizations in the second tab, Visualize. Kibana has a wide selec-tion of visualizations; line graphs, pie charts, area charts, and many others.

A basic use case is displaying how the number of visitors to a web-site varies across the hours of the day, days of the month. Zooming in and out of time scales is done by visual selection on the graph. If

you want to see how the number of visitors are distributed accord-ing to location, you can add a sub aggregation, and the bar lines of your graph will show color codes for different areas of origin. Alter-natively, they can be shown geo-graphically on a map. Using Kibana to it’s limits requires knowledge of how data is indexed, and how queries are executed under the hood. Kibana is created for devel-oper usability, having easy access to the raw data from Elasticsearch requests and responses. When you have created a set of visu-alizations supporting the analy-sis you’re working on, you can arrange them in the Dashboard tab and share it with your colleague, manager, customers etc.

ELK STACK AND THE FUTUREThe road from information to in sight is not determined by a machine, but by you, the user, developer, human being. An idea of what is of value and what should be sought after must inform the quest for informa-tion, not the other way around. The Elastic family of tools, rightly implemented, can be a step towards a movement of data analytics closer into the hands of those who understand their value.

Christoffer is working as a search consultant at Comperio, where he has been exposed to a wide range of search platforms. His education lies within the humanities, and is interested in both the conceptual and the practical side of computing. The true computer age has yet to come, he mumbled.

This graph shows an attempt to gain knowledge concerning the price range of Belgian beers containing significant Belgian beer terms (aka Belgianness) sold at Norwegian Vinmonopolet, using Elasticsearch and Kibana. The x axis shows beers, y axis is price pr alcohol unit, the colors indicate alcohol content.

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/products/dlm

@redgate /RedGateSoftwareTools /RedGateVideos

23

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/products/dlm

@redgate /RedGateSoftwareTools /RedGateVideos

24

Excited because the idea is one that almost all devel-opers can relate to and has likely at some point thought of implementing, for example when develop-ing a modern mobile application. Frustrating because it is not a trivial exercise to implement and the barrier to success was so high it was rarely feasible to imple-ment, both from a time perspective and when consid-ering return on investment. It was that elusive million dollar idea that was always just outside of your reach.

But this is all about to change.

HOW IT USED TO BEFor the most part developing software has always been platform specific. You chose your target device and then developed specifically for that target plat-form using the technology best suited for it. If you developed for a mobile platform, chances are you would use the .NET Compact Framework. If you

developed a desktop application you might use Win-Forms or WPF. And the choice was further compli-cated by each platform having different end goals, such as .NET Compact Framework aiming to preserve memory and battery. In essence you would have one product or solution for each platform.

The omni-presence of Windows 10by Lars Klint

25

In the day of Windows CE and the Compact .NET Framework, code convergence was not something that was easily achieved and if it was successful it was mainly for shared libraries and tooling. Very few applications were successful across platforms, but it did happen. Although it is only really starting to show now, code convergence is something Microsoft in particular has been working on for quite a while. CURRENT STATE OF AFFAIRSSo where are things at now? You may have heard of Xamarin, Cordova, PhoneGap or any of the other cross platform tools that can be used to write applica-tions for mobile devices. These are all tools that work great in different environments and for different pur-poses. They have certainly boosted both the uptake of cross platform development, and also increased productivity significantly. But no matter how you look at it, all of these tools are still built for a particular

purpose. They may fit your business aim perfectly and that is awesome, but they don’t address the funda-mental need for a native cross platform technology or approach. Xamarin is possibly what come closest to Nirvana when it comes to targeting multiple platforms with a single solution (especially as a developer on the Microsoft stack), and they are continually improving in great strides. But you are dependent on the vendor to improve and develop the tooling before you can target new platforms.

Wouldn’t it be great if your application would just run on the next platform that came out?

The potential of truly cross platform compatible development and applications have beenthe Promised Land for developers for decades. The notion of developing once and having yourefforts pay off exponentially by pushing out your work to multiple distinct platforms has always

excited, yet frustrated developers.

© D

abar

ti C

GI/S

hutt

erst

ock

26

THE PROMISED LANDAs you are reading this, I am almost certain you have heard of Windows 10 and its release this year. For some time it has been possible to download a tech-nical preview of the new operating system to get a feel for what has changed, but equally as important to provide feedback to Microsoft as users use it.

When most people hear “Windows”, they immedi-ately think of the desktop experience which has tradi-tionally been mostly correct. Now that notion is void. Windows will for the first time run on just about any-thing. I am talking phones, tablets, desktops, Internet of Things (IoT) devices (such as Raspberry Pi), Holo-Lens, Xbox One and anything new that comes out with a CPU capable of running Windows 10. That in itself is impressive, but the real key to making devel-opers’ lives easier and happier is in the Windows Runtime and universal apps for Windows.

Universal apps were introduced as part of Windows Phone 8.1 and Windows 8.1. It means you can write a single project that will currently target both phone and desktop/tablet. It takes the concept of portable class libraries one step further by having all outputs target the same core, namely Windows Runtime and even the user experience is also a single code base. This means developers are spending less time adjust-ing to each platform, and more time delivering busi-ness value.

For developers this is great news. Your current work will most likely be worth more in the future, rather than less, as applications can be run on more and more devices. Of course this depends on your appli-cation, but your efforts are certainly less likely to be obsolete the minute they reach production (as most software seems to be). This is the path to develop once, deploy many in a serious way. You will most likely be able to share libraries across platforms with little or no rework or compilation, and you can continue to use C# and XAML in Visual Stu-dio, which arguably is the best IDE available. There is no need for abstraction layers like Xamarin uses, as it is all run on the .Net framework and Windows Runtime. It will be a total experience in one, if I am to predict anything.

For consumers it has huge benefits. An app is bought once, then works on all their devices including hav-ing synchronised data. This enables users to switch between devices instantly when convenient and then continuing whatever they were doing. Or an app can be running on multiple devices with different aims, all contributing to a more full and immersive experience. Imagine having a medical application that simultane-ously projects data to HoloLens during surgery and updates the patient’s anaesthesiologist chart for opti-mal surgery and recovery time. That is not going to happen tomorrow or next year, but this technology certainly is headed in that direction.

And for businesses there are also great advantages. You can access critical data anywhere you might be on any device you have handy. The cost of developing and maintaining applications will be minimised as the work to deploy to new platforms and devices is much less as the framework will be the same.

I am not completely floating on rainbow coloured clouds here, as of course it is not all going to be smooth sailing. First of all there will be changes made to the Windows Runtime over time as more and more devices and architectures are supported, but com-pared to building everything from scratch or learning a new language or platform to move forward, this is a walk in the park. Second, users will have different objectives depending on which platforms they are tar-geting, hence the experience will have to be adapted to those needs. You can’t have a HoloLens projection working on a Raspberry PI with all likelihood. Microsoft is only just getting started with the cross platform strategy and Windows 10 combined with universal apps are a large part of this.

Lars is a solution architect with SSW, Pluralsight Author, Microsoft MVP and keen tech geek with a passion for the Microsoft ecosystem. He was selected among 10 in the world to participate in Nokia’s FutureCapture event and has spoken at a number of international events. Lars co-organises the DDD Melbourne conference and lives in rural Australia.

ProgramUtvikling offers the best courses and most flexible training to the developer community wherev-er you want us to. Our philosophy is to provide “prac-tical, applicable knowledge” by providing the highest quality training with the best instructors.In addition to our permanent staff we have a number of exciting and well-known instructors such as Herb

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

NDC has become one of the largest conferences dedicated to .NET and Agile development and is hosted by ProgramUtvikling AS.

www.ndcoslo.com www.ndc-london.com

We develop developersTraining and conferences in Oslo and London

OSLO - www.programutvikling.no

Phot

o: S

hutt

erst

ock

28

Big Scrum: Are you doing mechanical

Scrum? by Martin Hinshelwood

Are you doing mechanical Scrum? Also called flaccid Scrum, amateur Scrum, or by-the-book Scrum; all are equally ineffective. If you are not able to ship twice the features in half the time that you used

to, then you are probably doing mechanical Scrum.

© P

affy

/Shu

tter

stoc

k

29

Many organisations move towards Scrum and Agile for the allure of hyper-productivity and they are, more often than not, sorely disappointed when they don’t achieve it. The easiest way to make Scrum as ineffec-tive as possible, is to pay lip service to it. Forgetting about the values, principles, and technical excellence that are the underpinning of its effectiveness.

Mechanical Scrum is a place to start, just don’t expect to get the effectiveness that you desire. You need all three of the pillars to be able to ship twice the fea-tures in half the time.

THE DESIRE: TWICE THE FEATURESIN HALF THE TIMEYes really! You can ship twice the features in half the time, but only with Professional Scrum. In Profes-sional Scrum we not only follow the framework, but we enact the values and principles of the philosophy.

Jeff Sutherland talks often of using Scrum to make money as a venture capitalist by buying struggling companies. Jeff makes them profitable and competi-tive by implementing Professional Scrum. Profession-als will always be worth more than cowboys.

It beggars belief that so many organisations only prac-tice flaccid Scrum and waste their investors’ money. That’s bad when it is private investment, but down right criminal in a public company. And let’s not get started with the public sector.

Is your organisation paying lip service to the values and principles? Does it feel more like ‘yeeha’, or a group of professionals?

MECHANICAL SCRUM: IT’S A STARTMechanical Scrum is easy. All we have to do is to follow the framework and use the terminology. This is where most organisations start and unfortunately, where they finish. They think to themselves, “How do we satisfy the demand that we do Scrum, but not have to change actually?”.

Your organisational culture is finely tuned to cre-ate the situation that you are currently in. Changing that is hard, and it is disruptive so don’t expect even mechanical Scrum to be achieved without angst.

Often, a great time to change an organisation is when they have just catastrophically failed to deliver as you need to sense of urgency to create momentum for change.

VALUES & PRINCIPALS:START TO LIVE THE DREAMThere are five values that go with Scrum; commitment, focus, openness, respect, and courage. They should be applied to all aspects of the process, so they have dif-ferent meanings depending on the situation.

For example:

• The Development Team should have the courage to say “no” to the Product Owner when they don’t think that they can achieve what the Product Owner is asking from them within a given timeframe. The Product Owner should respect that the Develop-ment Team, as the ones doing the work, are best placed to make that decision.

• The Product Backlog should be open and transpar-ent to the rest of the organisation and the Product Owner presents the team’s focus through that backlog order. The business need to respect the Product Owner’s final position on the backlog order.

Along with the values, there are three principals that should be adhered to, time boxing, self-organising teams, and shippable code. At least once per sprint,

Sprint Retrospective

ProductBacklog

SprintPlanning

SprintBacklog

IntegratedIncrement

DailyScrum

ScrumTeam

ScrumTeam

SprintReview

@ Courtesy of Scrum.org


30

at the Sprint Review, you should have releasable soft-ware. This gives the Product Owner the option to ship if they desire to, it gives the business choice. This shippable increment of software occurs within specific timebox that is 30 days or less. Each of the events in Scrum adheres to a specific timebox that exists as a part of the overall Sprint timebox. Time-boxes should be sacrosanct, and the common cause is that you don’t break them.

Self-organisation is not synonymous to self-manag-ing, self-managing, and that is an important distinc-tion. Traditional managerial thinking was developed and honed in the days of the repetitive task and the unskilled workforce where the manager was often smarter than the workers. Mostly, and especially in software development this is no longer the case. Modern software development has more in common with painting the Mona Lisa than in building a model T Ford. Its creative work and no amount of effort will let you know exactly how long it will take until it’s done.

The traditional management roll morphs into one of mentor, coaching, and leadership.

TECHNICAL EXCELLENCE: BE THE BESTEven when organisations focus on the values and prin-cipals they often forget about technical excellence.

You need to train your Development Team members in the technology and the tools to make them effec-tive. They might need to brush up their skills in pat-terns and practices to allow the most flexible and rel-evant architecture emerge as they are building. Technical excellence is more than just having some skills, even if they are awesome skills. It’s about striving, at all times, to be the best at what you do.

To learn new techniques and technologies as they become available, and to actively spread that knowl-edge with your colleagues.

PROFESSIONAL SCRUM: DELIVER VALUEPut that all together and your business gets a Profes-sional Scrum Team that can deliver high quality work on a regular cadence that successfully and increas-ingly meets your business’s needs.

Professional Scrum focuses not on the iron triangle (time, resources, & features) but on the value deliv-ered to the customer. Does it really matter if you deliver twice as much, if you are delivering twice as much of no value? Focus on value, and manage that value.

In keeping with evidence-based techniques we need to monitor certain metrics so monitor our effective-ness at Professional Scrum. That’s not about keeping our Daily Scrum to 15 minutes, it’s about delivering value, early and often to the customer. The metrics that you monitor should reflect that mantra.

There is no one solution that will work everywhere. Your organisational culture is unique, and your goal is unique. You need to create a vision for your trans-formation and figure out what your first steps are. After trying them out, measure again, and see if you have made things better, or worse. Then continue to inspect and adapt your process, practices, and tools to better reflect the desired outcomes. Find your own path to agility within the structured framework of Scrum.

If you only have a single team, working against a Product Backlog, then Professional Scrum might just be your end goal. Focus on your vision and keep improving. SCALING PROFESSIONAL SCRUM: SCALING VALUE DELIVERYIf you have more teams working against a single back-log then you may need a little more. A single Product Owner, managing a single Product Backlog serviced by 6+-3 Professional Scrum Teams needs more struc-ture to make it work.



@ Courtesy of Microsoft

3 1

Each sprint still needs to create fully integrated work-ing software, and for that we need the concept of a Nexus. A Nexus is formed when more than two Pro-fessional Scrum teams have to work together.

The Nexus needs to plan together, review together and retrospect together. In short we need to make sure that communication is high and that we all know what is going on. With a Nexus there is an additional Integration Team, made up of representatives of each of the teams, that is responsible and accountable for making sure we get a single integrated increment of working software at the Sprint Review.

If you have a large application like Office or Salesforce you might need to break your application down into areas that are allocated to either individual Scrum Teams, or if there is enough work, a Nexus. Each would have a Product Area Backlog that is merely a subset of the Shared Product Backlog. You can imagine how hard that this is. Can you imagine if you has five Mechanical Scrum Teams? Do you think that you can pull it off? No, of course not… you need Pro-fessionals.

CONCLUSIONThe foundation for delivering high quality software that is of value to someone on a regular cadence is a Professional Scrum Team. You need not only the mechanics of Scrum, but also the Values, Principals, and Technical Excellence to be Professional. The only way to scale up is to bring more than one Professional Scrum Team together into a Nexus and integrate the practices that work within your organisation.

• Professional Scrum Team - A Team of 3-9 people who work together to deliver integrated working software each and every Sprint.

• Nexus - A group of 3-9 Professional Scrum Teams working together to deliver integrated working soft-ware.

You need to find your organisations own unique path to agility, what worked elsewhere is unlikely to work in the same way in your distinct organisational cul-ture.

Finding your path is hard, but there is help out there from: • Scrum.org: www.scrum.org• Evidence-based management: www.ebmgt.org• Scrum Guide:

www.scrumguides.org Recommended reading: • Scrum: The Art of Doing Twice the Work in Half the

Time: http://nkdalm.net/1Hf1Np0• The Leader’s Guide to Radical Management:

Reinventing the Workplace for the 21st Century http://nkdalm.net/1IJwjsa

• Software in 30 Days: How Agile Managers Beat the Odds, Delight Their Customers, and Leave Competitors in the Dust: http://nkdalm.net/19AoQPu

Martin Hinshelwood is a consultant for naked ALM Consulting, a technical and management consultancy that focuses on helping organisations modernise their development processes and enable a greater degreeof business agility. Martin works with one foot in the process space and one in the technical. He is a Professional Scrum Trainer and EBM Consultantwith Scrum.org with whome he has been workingsince 2010. He uses his knowledge and experienceto help organisations, large and small, to create professional development teams that produce high quality software that is of value to that organisation. Twitter: @MrHinsh

Nexus Sprint Retrospective

ProductBacklog

Nexus Sprint

Planning

Nexus

Nexus Nexus

Scrum Teams

Scrum Teams

Nexus Sprint

Backlog

IntegratedIncrement

NexusDaily

Scrum

DailyScrums

Nexus SprintReview




32

I have been around the Cloud when it was young and I have worked this market since the Cloud’s inception. This puts me in a position to notice the chang-ing trend of late. Starting after last summer there is a significant shift in real interest from custom-ers. I can also count the num-ber of requests for cooperation from other industry friends and experts to several per week com-pared to very few before summer. Suddenly the other experts get questions from their customers about that Cloud thing. Suddenly it seems “everyone” is aiming for

Cloudy business. Suddenly the Cloud became really relevant to everyone. I conclude that the mar-ket has finally crossed the chasm between early adopters and early majority on the Technology Adop-tion Lifecycle.

What we see now is the 80% body of the market reaching up for the Cloud almost at the same time. When this large part of the market is maneuvering to adopt a Cloud Strategy it certainly is rele-vant to stop and ask ourselves the important questions.

What are the key drivers that move our market to the Cloud? There are many insightful answers to that question but I would like to argue that the real driver is end user expectations. Tablets and smart phones have taught us consum-ers to expect a rich and immediate user experience even on a smaller form factor. Maybe even espe-cially on a smaller form factor? Very many consumers use their mobile device as their main way to access the Internet. Millions only ever access the Internet using a mobile device. This is more pre-dominant in markets where one

Applications to Appsbacked by the Cloud

by Magnus Mårtensson

The Cloud is not “a brave new world” anymore. At the same time in relation to the broad marketthe Cloud is finally catching on. If you ask me. Full disclosure – I’m a huge Cloud proponent andI work as an expert Cloud consultant mainly focused on the Azure Platform. I help companiesrebuild themselves and grow a relevant story in the Cloud, strategically as well as technically.

Of course I would express delight in that the Cloud is finally catching on!

© R

awpi

xel/S

hutt

erst

ock

33

device can be a significant invest-ment. In other parts of the world 29% of consumers carry more than three devices on a daily basis. I would love to be in the business of building power chargers today. Joking aside this is an astound-ing number! We bring all of our devices to work and expect to be able to access corporate systems with them.

Is this related at all to having a Cloud Strategy going forward? Without a doubt, yes, because the only real way to build a strong end user experience on multiple form factors and keep their multi-ple devices in sync is to use the Cloud! Admittedly there exist a few scenarios where a Cloud solu-tion is not the answer. However the vast majority of solutions that I have seen are not only a very good fit for public Cloud, they are

also without comparison much more cost effective when run as a Cloud solution. Total Cost of Ownership is not the main con-sideration though. If you are a more technical person you need to focus on the Cloud factor that is the most important to business decision makers and need to know what the key thing is that they will always listen to. The capabilities that public Cloud computing bring to your business, to what was before an old fat client Application, is to enable it to suddenly sprout wings and soar around the globe to new markets. If migrated care-fully your old dog has the poten-tial to learn some real new tricks, reach new markets and become, the Holy Grael of the Cloud, Mul-titenant.

In pre-Cloud markets we sold products based on license. In the new IT world in the Cloud we sell user-months or even user-hours. We host and run our “service”, no longer our “product”, in an elasti-cally scalable, global environment where we can go from a few thou-sand users to millions and still maintain a small crew to manage it. I heard that Instagram had a crew of 13 or was it 30 when they had 50 Million users! The exact number is not relevant but the trend is. IT business has become Multitenant and the Cloud has a fundamentally different cost model which opens up to an equally fun-damentally different business model. Gone are the days when you cared about on site installa-tions with every customer and the unescapable support monster that comes with it. In the Cloud you are instead supplying your service. You run and maintain your service and upgrade it when it suits your business needs, not your cus-tomers. Does Google ask Gmail users before upgrading their ser-vice? Maintenance and support costs are always radically less in the Cloud and furthermore selling a product to customers for them to install in their systems simply does not scale beyond a few hun-dred customers or maybe about a thousand.

I have many customers who have older products perhaps created in the nineties, written in Delphi. They built really great products for that era and have lots of satisfied customers over many years. There is certainly no shame here. What is a shame though is their feeling that they are slowly dying. Where is your public API? Do you have an iPad App or an Android App? The answer to those questions lie in creating a Cloud Strategy and migrating to the Cloud. Consider if a fraction only of the Cloud migra-tions people like me are dreaming of and hoping for actually will hap-pen. That will mean the biggest IT migration in the history of IT!

The race is long my friends and the big bulk of business has only just begun to move. I hope I have shown you the inevitability of your move to the Cloud, if you are already here congratulations! I know that the strongest contender in the Cloud is the Azure Platform. I purposefully stayed away from that discussion in this article but I’d love to hear from you if you want to talk about it! Flying in the Cloud is way more fun! I do it every day and it is glorious! Join us up here where the air is fresh and the sky is the limit!

Magnus Mårtensson is a Microsoft Regional Director from Sweden and a Microsoft Azure Most Valuable Profes-sional. In business as well as in life he is a true entertainer while being productive, smiles while being challenged, always gives more than is gained and aims not to take life too seriously because he claims it’s more fun that way!

34

The result would be a black box which would be easier to reason about, and which we could use to build bigger abstractions. How-ever, the typical experience has been that the spell of encapsula-tion fails. We cannot trust our black boxes because they tend to sur-prise us with their behavior! Invar-iably, therefore, we find that we need to peek into the box, to fig-ure out what went wrong. This is very bad. As a result, battle-scarred developers tend to prefer read-only objects whenever possible.

However, the reason that you introduce objects in the first place is that you want entities with memory! If your object is going to return the same result irrespec-tive of history, why not just use a function? So while understandable from a pragmatic point of view, read-only objects are really an admission of failure on behalf of objects. They are stones on a road that leads away from object-orien-tation and towards functional pro-gramming.

But why did encapsulation fail? Why are we unable to reason about our objects? Where did we go wrong?

The reason is the myriad possi-ble states for each of our objects. Consider for any non-trivial object in the application you’re currently working on:

- How many distinct states are possible? (Probably a very large number!)

Objects as we know them have failed. The original promise of objects was that we would givethem our state and they would encapsulate it - no need for us to worry!

Objects as state machines

by Einar W. Høst

© H

chjjl

/Shu

tter

stoc

k

35

- How many states are legal or meaningful? (Might be smaller but tends to be unknown or ill defined.)

- How many states affect behav-ior? (Probably much smaller, but tends to be unknown or ill defined.)

But we cannot reason about objects unless we have absolutely precise answers to these questions! They should be manifest in both dia-grams and tests!

The good news is that our ina-bility to answer these questions reflect a lack of design. This, in turn, means that the problem can be fixed.

We can start by making a distinc-tion between fields that influence behavior and fields that do not. Then, for the fields that influence behavior, we must specify precisely what that influence is. We should go further and enumerate and name all the distinct possible states of our objects. This is the road that leads to proper object-orientation.

The solution is to treat our objects as state machines. A state machine is a mathematical model of com-putation which consists of the fol-lowing:

- A set of possible states (of which one will be the start state)

- A set of possible inputs

- A transition function between states.

This is the mechanism that will al low us to reason about our objects. Armed with this knowl-edge, we can answer all the ques-tions above. No more hand-waving and vague answers: we can be completely explicit about the num-ber of distinct states our objects will have, which inputs will affect the objects’ state and hence their behavior, and what the effect of a given input will be.

A state machine is not only a cure for ambiguity, it also eminently documentable. This, in turn, means it can act as a vehicle for design

discussions. It is easy to draw on a whiteboard, in a written docu-ment or on a wiki page, typically in the form of a table or a graph. The mere exercise of doing so may reveal shortcomings in the design, or suggest improvements, missing functionality and so forth.

Consider an example. My favorite state machine example is a baby, but you could of course imagine all kinds of dull enterprisey domain objects instead, like an account, a process or an invoice. The principle is the same.

As a parent, you want your baby to be either in happy state or a sleeping state. Invariably, though, it enters that less desirable state of screaming. Unfortunately, this is just the observable state. Your baby is effectively a black box. The observed screaming could be caused by any number of hidden inner states, and so you resort to trying various inputs like singing a lullaby, giving it a rattle, breastfeed-ing and so forth.

36

The figure above shows a simple diagram of a baby state machine, including several of those devious inner states which so frustrate parents. (The good thing about designing the state machine your-self is that you get to define the inner states and how they relate!) This particular diagram is a snap-shot of a “live” diagram generated by graphviz based on output from a very simple “baby simulator” application. It is “live” in the sense that it monitors a running state

machine and highlights the cur-rent state (in this case, the baby is “bored”). The diagram also exhib-its a problem in the current state machine - can you spot it? How would you wake the baby?

When implementing an object as a state machine, the abstraction is the important thing. The object should act as a state machine; that is, it should always be in some named and queryable state, and it should accept inputs of a certain type. The

implementation details are just that: implementation details. In fact, the internals could be a complete mess of boolean flags as long as it ful-fills the contract! But there are of course much better alternatives. In the “baby simulator” application I used a very generic approach, which involves the following three simple interfaces.

Each state machine implements IAmMachine , each state imple-ments IAmState, and each transi-tion implements IAmTransition. As you can see, each state has a name and is associated with a sequence of transitions to other states. Each transition in turn has a predicate that is used to deter-mine if the transition may be fol-lowed given a certain input. It is the responsibility of the machine to try the transitions in sequence and follow along to the target state of a transition if one is fulfilled.

One nice thing about this approach is that it lends itself very well to generic visualizations of the kind we saw in the diagram above. But again, the important thing is the abstraction, not the actual imple-mentation. As long as you have a state machine that allows you to answer the three questions about state above, you’ll have an object that works.

public interface IAmMachine<T>{ IAmState<T> CurrentState { get; } void Accept(T input);} public interface IAmState<T>{ string Name { get; } void Accept(T t); IEnumerable<IAmTransition<T>> Transitions { get; }} public interface IAmTransition<T>{ bool Evaluate(T t); IAmState<T> Target { get; }}

Einar W. Høst is a developer and technical architect at Computas. He thinks we should try to learn from history, so that at least we make new mistakes rather than the same old ones. In his spare time, though, he makes old mistakes in new ways, and blogs about the results. He holds a PhD in Computer Science from the University of Oslo.

37

REACT WORKSHOP WEB JAVASCRIPT27. August with Eirik Langholm Vullum - 2 daysReact is a JavaScript library initially developed internally by Facebook/Instagram and open-sourced in 2013. It introduces a new way of thinking when it comes to building user interfaces in JavaScript. With its declarative style and virtual DOM-diffing algorithm it challenges established best practices. What does this mean for you? Faster, more maintainable applications that are easier to test, debug and reason about. Don’t want to go all-in? Don’t worry. Dip your toes in. React facilitates being used in as small or large a part of your application as you want to.

ADVANCED C++ PROGRAMMING AND INTRODUCTION TO C++11 C++14. September in Kongsberg and 12. October in Oslo with 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. It will cover techniques and idioms that allow for more efficient and safer use of the language as well as the concepts that make C++ different from other languages. Modern C++ techniques and facilities such as the STL are used throughout to introduce developers to the full power of the C++ language. One day is devoted to new C++11 features.

CERTIFIED SCRUMMASTER (CSM) 15. June with Daniel GulloThis 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.

CERTIFIED SCRUM PRODUCT OWNER (CSPO)15. June with Daniel GulloCompletion of this two day course results in participants becoming certified as recognised Scrum Product Owners.

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

AGILE DESIGN AND MODELING FOR ADVANCED OBJECT DESIGN WITH PATTERNS22. February 2016 in Oslo with Craig LarmanThis 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.

Courses by

38

No longer is native the only option for a mobile applica-tion. Cross-Platform hybrid applications have become a viable solution. These applications are web based applications that run directly on the device and are able to interact with the device to use features such as GPS location, contacts, and camera. You might be going wait a second, hybrid applications are nothing new. Yes, it is true that we have had the ability for a few years to compile the web code into a native application using Cordova. However, the per-formance was not very good as there was not a UI framework that was optimized for mobile devices. This is where the Ionic Framework (http://www.ionicframe-work.com/) comes in. It is the missing UI framework for hybrid applications.

The Ionic Framework is designed as a mobile device first UI framework and is obsessed with providing the look, feel, and performance of a native application. The Ionic Framework utilizes web technologies that we know and love such as Html 5, Javascript, Css, and AngularJS to accomplish these goals. It includes the standard controls that you would expect in a native application such as list, menus, modals, pull to refresh, navigation, plus more.

The documentation for all of the controls is available at (http://www.ionicframework.com/docs) with lots of interactive examples and code that you can instantly use. There is also over 600 free font based icons included from Ionicons (http://www.ionicons.com/).

Hybrid Mobile Developmentwith the Ionic Framework

by Justin James

Not long ago if you wanted to create a great performing mobile application for iOS orAndroid you had to build it as a native application using Objective-C (iOS) and Java (Android).These languages are very different from each other, take a long time to master and you end

up having to maintain two separate code bases for the same application.

39

INSTALLING THE IONIC FRAMEWORKTo install the Ionic Framework, you need to first install NodeJS from (https://nodejs.org/). Once you have node installed, open a command prompt and run the command npm install -g ionic cordova.

CREATING YOUR FIRST IONIC APPLICATIONTo create your first Ionic application, open a command prompt, navigate to where you typically keep your coding projects and run the command ionic start myFirstApp tabs. This will make a directory called myFirstApp and an Ionic project based on the tabs template. Ionic has 3 templates included: blank, tabs, and side menu. Feel free to try out all three of them.

Now that you have your project created, in the com-mand prompt navigate to the myFirstApp directory, run the command ionic serve and then open your web browser to (http://localhost:8100/). Your web browser should be viewing a page that looks like the figure to the right.

© S

enta

vio/

Shu

tter

stoc

k

40

EDITING YOUR APPLICATIONYou are ready to start editing your application files. All of your applications files are under in the www direc-tory and can be edited in the text editor of your choice. Within the WWW directory is one file (index.html) and several directories. • Index.html – the main html view that loads all of

the views, JavaScript, and css files. • CSS – Used for your custom styles• Img – Used to hold your images• Js – Used for your JavaScript files, controllers,

services, app.js, etc• Lib – used to store the vendor JavaScript files such

as AngularJS and Ionic.• Templates – used to hold your html views

With the ionic serve command running, as you edit files they will be automatically reloaded in the web browser. DEPLOYING YOUR FIRSTAPPLICATION TO A DEVICESince this is a mobile application, I know that you want to see it running on your mobile device. The setup needed to deploy to a device is not specific to the Ionic framework and is the same software that is required by Apple and Google to compile a native application. For this article, we are going to deploy your application to an Android device. Don’t worry if you don’t have a physical device, you can use an Android emulator. INSTALLING AND CONFIGURING ANDROID SOFTWAREBefore you can deploy to a device, you need to install a little bit of additional software. You will need Java

Development Kit 7 (JDK), Android Studio, Android SDK, and Apache Ant. For Mac OS, the setup instruc-tions are available at (http://digitaldrummerj.me/ion-ic-setup-osx/). For a Windows machine, the setup instructions are available at (http://digitaldrummerj.me/Ionic-Setup-Windows/).

EMULATOR SETUPIf you do not have a physical Android device you will need to use an emulator. Your best option is to download Genymotion from (http://www.genymotion.com/).

After Genymotion is installed, open up the Genymo-tion UI and click on the Add Button. Then click the Sign in button and follow the login instructions to login with the account that you create as part of the Genymotion download. After you are logged in, select from the Android Version drop down 4.4.4, from the Device model drop down select a device type, then select a device from the available list and click the Next button. On the next screen, click the Next but-ton, wait for the device to download and finally click the Finish button. Select the device that you just downloaded and click the start button. Your emulator should now be up and running.

DEVICE DEVELOPER MODEIf you are using a physical Android device, you need to put the device into developer mode in order to deploy your Ionic application to it. 1. Open the Settings application, go to the about

page and click on the Build number 7 times. 2. Hit the back button, click on the “{} Developer

Options”, and check the “Usb Debugging” option. 3. Hit the back button, click on the “Security” page

and check the “Unknown Sources” option.

41

DEPLOYING TO THE DEVICENext you need to do is tell the Ionic Framework that you want to compile for Android to by running the command, ionic platform add android. Finally, run the command, ionic run android to deploy it to the device. Your application should now be running on the device. ADDITIONAL TOOLS PROVIDED BY THE IONIC FRAMEWORKAlong with all of the amazing code provided by the Ionic Framework, they have several extremely useful tools that are also free. • Ionic Creator - Rapidly build Ionic applications with

a drag and drop interface and real code exporting – (http://creator.ionic.io/).

• Ionic View - Easily share your Ionic application with clients and testers around the world, all without ever going through the App Store - (http://view.ionic.io/).

• Automate icon and splash screen generation - (http://blog.ionic.io/2015/01/05/automating-icons-and-splash-screens/)

• Crosswalk integration for Android developers to ensure performance and predictability across Android devices and OS versions - (http://blog.ionic.io/2015/01/12/crosswalk-comes-to-ionic/).

• Interact with the native device capabilities using simple AngularJS wrappers for the most popular Cordova and PhoneGap plugins – (http://www.ngcordova.com/).

ADDITIONAL RESOURCES• Ionic Framework Blog:

(http://blog.ionic.io) Ionic Framework Forum: (http://forum.ionicframework.com/)

• Nic Raboy’s Blog: (http://blog.nraboy.com)

• Andrew McGivery’s Blog: (http://mcgivery.com/)

WRAP UP It is time to go and build your next mobile application. With all of the built-in functionality and tools included with the Ionic Framework, you can use modern web technologies to quickly create and release an appli-cation that works on iOS and Android with one code base. I look forward to seeing what you are build.

Justin is a developer and speaker focused ASP.NET,C#, AngularJS, and Ionic. He has a passion for web development and teaching. You can find him online at http://digitaldrummerj.me or @digitaldrummerj.

© S

enta

vio/

Shu

tter

stoc

k

42ndcoslo.com@NDC_conferences #ndcoslo

We are proud to present the 8th NDC. Thanks to our inspiring partners who make it happen!

For information about partnership deals, please contact:[email protected] tel.: +47 67 10 65 65

SINCE 2008

Become a partner

today!

43ndcoslo.com@NDC_conferences #ndcoslo

We are proud to present the 8th NDC. Thanks to our inspiring partners who make it happen!

For information about partnership deals, please contact:[email protected] tel.: +47 67 10 65 65

SINCE 2008

Become a partner

today!

44

Resolving Conflictsin Occasionally Connected

Mobile Appsby Michael L. Perry

45

INCONCEIVABLE!Vizzini yells “Move the thing!” He also adds a card to a Kanban board on his mobile app. It appears in the To Do column.

Fezzik also has the app installed on his phone. A toast notification alerts him that there is a new card, so he opens the app and sees “Move the thing” in the To Do column. He slides it to Doing, and then proceeds to move the thing.

When Fezzik is finished, he moves the card from the Doing column to Done. At this exact moment, however, Vizzini changes his mind. He yells “No, the other thing!” and slides the card from the Doing column to To Do.

Now the two apps are in conflict. They each see two different series of events leading up to opposing states.

Which series is correct? How should the app respond? How should the conflict be resolved?

What if the app displayed the conflict to both Vizzini and Fezzik? Vizzini, upon seeing the problem, would move the card to the To Do column, thus resolving the conflict.

© M

axim

Kos

tenk

o/S

hutt

erst

ock

46

CONFLICT VS INCONSISTENCYA well-behaved mobile app knows the difference between a conflict and an inconsistency. A conflict is a condition that arises when two different parties make different decisions based on the same informa-tion without knowledge of the other. Inconsistency, however, is when two nodes see the system in dif-ferent states. Conflicts are inevitable when consist-ency cannot be guaranteed. But even if we can’t have consistency at all times, we can have consistency eventually. Eventually, both Vizzini and Fezzik saw the system in the same state: a state of conflict. The sys-tem reached a consistent state precisely by exposing the conflict.

There are systems that honor this distinction between conflict and inconsistency. Two examples are Git and Bitcoin.

In a Git repository, commits are allowed to co-exist in a state of conflict. Two branches diverge from the same point in history. Along one branch, one com-mit changes a file. Along another, a second commit changes the same file in a conflicting way. The conflict cannot be resolved automatically; human intervention will be required at some point in the future.

In Bitcoin, transactions are added in blocks to the end of a block chain. Nodes in a worldwide distributed system compete to find the next block. For a time, two blocks may simultaneously exist on the end of the chain, forked from the same predecessor. While the system is in this state, the transactions in those two blocks are in conflict. However at some point the next block will be discovered, deciding which of the two chains is accepted and which is abandoned.

Both Git and Bitcoin represent conflicts in the same way. A Git commit and a Bitcoin block both contain the cryptographic hash of their predecessor. A con-flict has occurred when two commits or two blocks – contain the same predecessor hash. Seen as a tree, a conflict occurs when there is more than one leaf.

But Git and Bitcoin represent the resolution of the conflict differently. Git resolves conflicts by creating a merge commit, containing two predecessor hashes. But a Bitcoin block contains only one predecessor hash. When a new block is discovered, the longer chain is accepted while the shorter one is abandoned. (A Git rebase is more akin to a Bitcoin chain, in that the original branch is abandoned.)

The real insight of the Git and Bitcoin solutions is the separation of conflict resolution from communication. Moving the event is distinct from resolving the con-flict. When nodes communicate with each other, they exchange information without judgement of conflicts. Conflicting commits or blocks are allowed to coexist without question for long periods of time.

HISTORICAL MODELINGLet us now return to Vizzini and poor Fezzik. How should their Kanban application be constructed? One way to construct an occasionally connected mobile app is to employ Event Sourcing. Greg Young defines Event Sourcing as “storing current state as a series of events and rebuilding state within the system by replaying that series of events.” (http://codebetter.com/gregyoung/2010/02/16/cqrs-task-based-uis-event-sourcing-agh/)

In storing events in a series, Event Sourcing imposes a total ordering upon those events. To replay a series of events, it is important that they be read back in exactly that order. Unfortunately, events in an occa-sionally connected mobile app do not occur in series. Both Vizzini and Fezzik made correct decisions with the information at their disposal. Requiring a total order would deny one of them that ability. To place their events in series, one of them would have to per-form the equivalent of a Git rebase, and abandon their intended branch.

47

Instead, let us keep the spirit of Event Sourcing and replace its implementation. Let’s replace a total order among events with a partial order among historical facts. Unlike events, facts cannot be replayed; their order cannot be unambiguously determined. But, much like Git commits or Bitcoin blocks, they capture the causal relationships that lead up to the fact. They contain the hash of their predecessors, and can there-fore represent a conflict while still achieving eventual consistency.

REPRESENTING A CONFLICTWhen Vizzini and Fezzik create the conflict, the his-torical model captures their intent. At first, they see only their local version of history. During this time, each tree had exactly one leaf, and so there was no apparent conflict. However, once they exchanged facts, they both saw a tree with two leaves. They had eventually achieved consistency; both saw the same state. However that state was one of conflict.

Upon seeing the conflict, Vizzini takes the initiative to resolve it. He moves the card, and in so doing cre-ates a fact having two predecessors. Much like a Git merge, this new fact succeeds the two conflicting facts and grafts the tree. This fact is shared with Fez-zik, and both can now see a tree with only one leaf; the conflict is resolved.

As opposed to a totally ordered series of events, a partially ordered graph of facts can represent a con-flict and its resolution. Facts are sent and received without concern for whether they cause a conflict. Moving facts through the system is one concern; detecting and resolving conflicts is a completely sep-arate endeavor. The historical model allows conflicts to stand until the human decides to intervene.

Software is math. Every class is a theorem. The compiler is the proof. And unit tests check our work.

Michael has recorded Plural-sight courses on CQRS, XAML Patterns, and Cryptography, in addition to Provable Code. He maintains the spoon-bending Assisticant and Correspondence open-source libraries. And he helps his clients at Improving Enterprises.

© M

axim

Kos

tenk

o/S

hutt

erst

ock

48

My better half Dina, who is also a software developer, has recently run into the problem of analyz-ing production issues using dump files. She knows very well how to open a dump file in Visual Studio or WinDbg and extract basic exception details, but she was getting dozens of dump files every day and the rate was increasing with the extent of their production deployment. Open-ing each dump file and analyzing it by hand simply doesn’t scale.

In the past, possible solutions would include setting up a collec-tion of contrived command-line and WinDbg scripts to extract information from dump files auto-matically. WinDbg commands produce text output which can be parsed by another program, which helps extract basic exception information, call stacks, and other simple features required to ana-lyze the problem. But higher-level analysis, such as looking at heap usage statistics, inspecting individ-ual objects, perusing synchroniza-tion mechanisms and inter-thread relationships—this kind of analysis is infeasible with command-line scripts and text parsing.

Almost two years ago, Microsoft introduced a free library, which was later open-sourced, called ClrMD (CLR Memory Diagnostics). It is available as a NuGet package, and provides a .NET-friendly API for analyzing dump files and connect-ing to live processes. I was posi-tively shocked to see the extent and potential of this library! Here are just a few of the things you can do with ClrMD:

• Open a dump file and extract exception information and the call stack of the faulting thread

• Collect heap statistics on all live/dead objects in terms of types, counts, and sizes

• Locate an individual object and inspect its properties, without even suspending the target pro-cess that you’re inspecting

• For each blocked thread, deter-mine the blocking object that keeps it waiting and the owner thread of that blocking object, if one is available (which serves as the foundation for deadlock detection)

These incredibly powerful fea-tures don’t come at the expense of performance. ClrMD is full to the brim with caching tricks and other optimizations that ensure your analysis is almost as fast as reading from the memory of your own process. For example, even without applying any optimizations of my own, I was able to traverse all the managed heap objects in a heavy Visual Studio process and collect type statistics in just a few seconds.

On this GitHub Gist, (https://gist.github.com/goldshtn/3c55d83f-faa495327504) you can find a complete example of a program that opens a crash dump file and extracts basic information for the thread that caused the crash. You’ll notice the API is quite simple – the DataTarget class represents a dump file or a running process, the ClrRuntime class represents a specific version of the Common Language Runtime loaded into that process, and the ClrThread, Clr-Exception, and ClrStackFrame classes are quite self-explanatory as well.

Analyzing thousands of dump files

from production systemsby Sasha Goldshtein

Are you using dump files to analyze issues in your .NET applications? This short article mayhelp you set up an automatic process that inspects dump files and extracts interesting insights

without human intervention

49

Based on the experience of cre-ating fairly complex ClrMD-based solutions, I can say that ClrMD really tends to make the complex tasks quite simple. Although some things about the CLR simply require a bit of work—for example, to determine whether an object is live from the GC’s perspective you have to perform a graph search from the set of GC roots—the ClrMD API is very helpful, polished, and intuitive. You can find some additional sam-ples that range from simple to very complex on the Microsoft official .NET samples GitHub repository,

(https://github.com/Microsoft/dotnetsamples), including a sam-ple that performs complete heap walking.

I will be more than happy to help and collaborate on any projects that use ClrMD to build sophis-ticated analysis solutions, from dump analysis to live process inspection. You’re also very wel-come to get in touch if you have any questions or ideas about ClrMD, and I can help connect you to the library’s author.

using Microsoft.Diagnostics.Runtime;using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks; namespace ClrMD{ class Program { static void Main(string[ ] args) { if (args.Length == 0) { Console.WriteLine(“Usage: <crash dump file>”); return; } DataTarget target = DataTarget.LoadCrashDump(args[1]); ClrRuntime runtime = target.CreateRuntime(target.ClrVersions[0].TryGetDacLocation()); foreach (ClrThread thread in runtime.Threads) { ClrException exception = thread.CurrentException; if (exception == null) continue; Console.WriteLine(“Exception {0}: {1}”, exception.Type.Name, exception.Message); PrintCallStack(exception.StackTrace); } } private static void PrintCallStack(IList<ClrStackFrame> callStack) { foreach (ClrStackFrame frame in callStack) { SourceLocation sourceLocation = frame.GetFileAndLineNumber(); string source = (sourceLocation == null) ? “” : (sourceLocation.FilePath + “@” + sourceLocation.LineNumber); Console.WriteLine(“{0} {1}”, frame.DisplayString, source); } } }}

Sasha Goldshtein is the CTO of Sela Group, a Microsoft C# MVP and Azure MRS, a Pluralsight author, and an international consultant and trainer. Sasha is also the author of two books, a prolific blogger, and author of numerous training courses.

50

The emergent nature of software architecture

Tudor Gîrba

The architecture of a software system is not a document. It is the reality of the system that is the result of multiple developers working at the same time and committing

code concomitantly in different corners of the system.

It is the result of following the constraints posed by the system’s current state. It is the result of the social interactions between the team, product owners and other stakeholders. It is the result of what is possible with the underlying languages and technologies. It is the result of skills. It is the result of taste. It is the result of dreams.

In short, architecture is an emergent property created by multiple agents interacting constantly with each other. And like any respectable emer-gent property it is hard to communicate, and even harder to figure out how to approach it. To under-stand it better, let us visualize the problem.

5 1

The picture shows details of a real system. Classes are black. Methods are red. Attributes are blue. Method containment, attribute containment, and class inheritance are gray. Invocations are red. Attribute accesses are blue. And everything is arranged through a force-based layout. The visuali-zation is called System Attraction and it is produced using the Moose analysis platform (http://moose-technology.org).

While things might appear random at first, at a deeper look there is a certain order that emerges from all the entangling. Colors are not uniformly distributed throughout the space. At the center, there appears to be much agglomeration of red surrounded by blue. This seems to indicate that there exists a consolidated behavior at the center of the system. There are groups of black spots (i.e., classes) that want to be close together. Also, the blue backbone on the bottom right seems to indicate a significant aggregation of related data.

To get a better feeling for how systems can be different, let’s compare the above example with the one below. The two systems are comparable in size, yet they exhibit much different patterns. The second system is much stronger on state. In fact, it looks as if it’s the data that drives the sys-tem, and methods are just adjacent. Furthermore, while the first system seems to have at least one strong agglomeration of behavior, the second one has multiple small ones.

These picture exhibit macro emergent patterns that are determined by forces in the code. For example, a method is indeed attached to its classes, but if there are many other external inter-actions, the method will tend to go away from its class. The visualization lets the sum of all these forces decide the shape of the system. Essen-tially, the visualization lets the code go both where it is needed and next to what it needs.

52

Now, let us take a step back and take a closer look at one class. This class has a classic structure with multiple methods (red circles) and few attributes (blue circles). The methods seem to collaborate with one another and the attribute usage is reasonably distributed throughout the methods. It looks like a tidy class with proper structure in place.

Let us now add to our scene a collaborator class next to the original one.

The class changes its shape a bit, and one method in particular seems to be more attracted to the new-comer. Let us add another one.

53

The shape changes a bit more. Now, let’s see what happens when we visualize this class together with all its provider and client classes.

Ahh, where is our class now? The tiny tidy shape cannot be seen anymore.

When placed next to its collaborators, the class changes shape dramatically. Regularity is second-ary to distinct interests. For example, a group of four methods wants to be the center of everyone’s attention, while some other methods want to min-gle with other classes in the north.

Software architecture is an emergent property. Clearly, this shape of the system does not reflect any traditional view on architecture. There are no model-view-controller or layer patterns to be found. Nevertheless, visual patterns do emerge. And what is architecture if not the structure that defines the system?

Let us highlight it.

54

Indeed, when we look at the code only through a diagram that imposes a predefined grid, such as a UML diagram, we will tend to see only the defined regularities. These visualizations are not bad. They have their place precisely when it is those regularities we want to reason about. But, only being exposed to rigid shapes encourages a type of thinking that leads to the illusion of com-plete controllability.

A common point of view says that architecture is only to be seen in the large. Yet, the forces embed-ded in the code influence the shape of the system in the small as well. Even if it is more comfortable to see a class as having a regular and controllable shape, when seen in its usage environment, the shape can morph in unexpected ways. This shows that code can be understood effectively only in context.

In our exercise we only looked at simple code ele-ments such as classes and methods and standard interactions such as inheritance and invocations. We completely ignored technology specific details. We completely ignored the social behavior around the software system. And we only looked at one snapshot of the system. Even so, the experiment shows that software architecture is driven by interaction and it is never single minded. Only by acknowledging the underlying forces in a software system can we handle them appropriately.

Software architecture is an emergent property. It cannot be controlled upfront, but it can be steered.

First, we need to acknowledge that the current shape and forces will change all the time and the only way to make informed decisions is to under-stand the current state. This can only happen through appropriate tools and techniques that go beyond manual code reading.

Second, we need to stop believing that one indi-vidual can be in control. We need to move from a controlling model towards a distributed one in which everyone is empowered to contribute at every given moment.

Tudor Gîrba (http://tudorgirba.com) works as team and innovation lead at CompuGroup Medical Schweiz, and as an independent consultant.

He leads the work on the Moose platform for software and data analysis (http://moosetechnology.org), he founded the Glamorous Toolkit project for rethinking the IDE (http://gt.moosetechnology.org), and he is a board member of the Pharo live programming environment (http://pharo.org).

He developed the humane assessment method (http://humane-assessment.com), and he is helping companies to rethink the way they manage complex software systems and data sets. Furthermore, Tudor developed the demo-driven innovation method (http://demodriven.com) as a combination of design thinking, idea prototyping and storytelling.

In 2014, he won the prestigious Dahl-Nygaard Junior Prize (http://aito.org) for his work on modeling and visualization of evolution and interplay of large numbers of objects.

55

56

WHAT ARE STATIC WEBSITESStatic websites are just a bunch of pre-generated files (e.g HTML, CSS, JavaScript). They are gener-ated once and served to all the vis-itors. A webserver hosting static files needs way less resources than a traditional application server. It is no problem anymore if your website gets promoted or thou-sands of Reddit or Hacker News visitors flood your pages. Your servers will withstand the pres-sure – SSDs are cheap nowadays.

Static websites are usually hosted with time-tested, well-maintained, open source server software –think of NGINX, Apache, Varnish, Lighttpd. Your stack gets less com-plex with not having to host any custom code. This makes static websites much less vulnarable to hacking. There is much less chance for software bugs and issues.

HOW TO DEVELOP STATIC WEBSITESStatic websites do not mean writ-ing your HTML files in a plain text editor without any convenience of modern technology. You can still use HTML templating, build-tools, databases and any kind of tech-nology you are used to. The only difference is that the website is not going to be generated on the webservers, but the pre-generated files get copied to the servers.

A usual development workflow contains the following steps:

- Creating page templates

- Designing HTML partials – header, footer and other common elements which are present on all or many of the pages

- Pairing content with templates, generating the HTML files – usually using markdown

- Running tests on the files – checking that all links work correctly, checking the count of the files and so on...

- Deploying the files to production – e.g. SSH, SCP, rsync

- Running the same tests in the live environment as during devel-opment. This should make sure that everything went fine and is working as expected.

Hosting static websites is as easy as hosting some static files. You can use:

- any conventional website hosting providers

- [GitHub Pages] (https://pages.github.com/)

- [Google Drive](http://bdadam.com/blog/hosting-static-web-

pages-and-assets-with-google-drive.html), Dropbox and many other services

- your own server

- and many more...

GIVE IT A TRYThere are many great tools which are perfect to start with. Let’s take a look at a few of them. A more complete list can be found on [staticgen.com](https://www.stat-icgen.com/) and on [staticsitegen-erators.net](https://staticsitegen-erators.net/).

To name some of the tools:

- [Assemble](http://assemble.io/) – written in JavaScript for [GruntJS](http://gruntjs.com/).

- [Jekyll](http://jekyllrb.com/) – used to be the de facto standard for the Ruby community.

- [Hugo](http://gohugo.io/) – written in GO. It is optimized for speed, easy use and configurability.

- [Metalsmith](http://www.met-alsmith.io/) – written in JavaScript. “All of the logic in Metalsmith is handled by plugins. You simply chain them together.”

- [harp](http://harpjs.com/) – also written in JavaScript

Static websites are goodfor your health

by Adam Beres-Deak

Some time ago I was going to start a new project. I wanted to have a development blog,where I could keep notes for my future self. I was facing a tough question: What kind of

content management system (CMS) or blog engine should I use? I listed all the usual options(using Wordpress, Craft, creating my own). Then I ended up with a static website.

57

IS IT A SILVER BULLET?Unfortunately static websites can-not be used in every situation. They are not suited for frequently changing content. You cannot use them either without forgoing fea-tures like a web based page editor, user login, online content man-agemenet or complex server side business logic.

HOW ABOUT SOME CHEATING?Yes, some cheating in this case is possible and for once acceptable. If you do not want to do without the convenience feature of modern CMS solutions, you can still use some kind of staticness. Almost every webserver software can be set up to provide caching. When the first visitor downloads a page the server caches the response from your CMS in a local file. For other visitors the server can send directly back the already cached response – without having to touch your application.

HOW DO STATIC WEBSITES INFLUENCE PEOPLE’S HEALTH?In the title I said static websites are good for your health. But how?

If you are a website hoster then you have to worry less about server performance or about being hacked. You can be happy about overnight success, without fearing overloaded servers. This makes you more healthy.

If you are a software developer then you will be more healthy as well, because you can be sure that your website will behave the same on your machine and in production. There are no more bugs which only occure on live servers.

Users will also be much happier. They get faster websites and reduced load times.

This is a win-win situation for everyone.

Adam is a software engineer at AutoScout24, which is Europe’s biggest car market in more than 10 countries. He has been developing for the web since the beginning of the Web 2.0 Era. His motto in life is “Simplicity is the key for success”. Adam feels at home in JavaScript and Node.js, but also devel-ops with ASP.Net/C# and Python.

© R

acor

n/S

hutt

erst

ock

58

CLUTTER EVERYWHEREWhen I was a fresh-faced college graduate stepping into the world of programming, the language that was all the rage was C, and the state-of-the-art in windows pro-gramming was COM. We prided ourselves in writing safe code that other COM com-ponents couldn’t bring down; and we did that by guarding every function call with error checking and recovery code.

Clutter-Free Programmingby John Azariah

hr = pDest->put_Provider(varProvider.ChangeTypeToANSI());if (FAILED(hr))return hr;

var.Clear();

if (SUCC(pTemp->get_Views(&var))){ hr = pDest->put_Views(var.ChangeTypeToANSI()); if (FAILED(hr)) return hr; var.Clear();}if (SUCC(pTemp->get_Template(&var))){ hr = pDest->put_Template(var.ChangeTypeToANSI()); if (FAILED(hr)) return hr; var.Clear();}if (SUCC(pTemp->get_DefView(&var))){ hr = pDest->put_DefView(var.ChangeTypeToANSI()); if (FAILED(hr)) return hr; var.Clear();}

Clutter-Free Programmingby John Azariah

59

I don’t believe that most programmers today apply the same level of paranoia in today’s programming environments. After all, we’ve got managed memory, don’t have to do reference counting, and we have exceptions for structured error handling.

Surely our code is cleaner now!

do{ try { var xnInternal_DeletedTime = xn.SelectSingleNode(“./Internal_DeletedTime”); if (xnInternal_DeletedTime.InnerXml == “”) { break; }

var value = xnInternal_DeletedTime.InnerText; Instance.m_Internal_DeletedTime = DateTime.Parse(value); } catch (Exception) { break; }}while (false);

© M

aryu

tin M

axim

/Shu

tter

stoc

k

60

Unfortunately, code like this snippet is still prolific! It’s clear that we haven’t reduced the clutter by improving the runtime environment. Guarding against null values; handling failures and exceptions; attempt-ing to cast or coerce values between types; logging of activities; and many such patterns are prevalent in modern code. Indeed, distributed computing and ser-vice-oriented programming bring many more patterns to deal with transient and permanent communication failures.

So not only is such code prolific, it turns out that the patterns actually are useful, and provide structural safety to the logic portion of our programs. This is especially true in well-designed service-ori-ented architectures, where the desire is to encap-sulate behaviours into decoupled services, and then compose those services together in a safe manner – addressing issues such as retry mechanisms for tran-sient failures; circuit-breaker mechanisms for perma-nent failures; service-monitoring; authentication and authorization; and all the infrastructural support that is required to build resilient systems in a manageable way.

This system of thinking is not new. In fact, the notion of composability is one of the strongest weapons in the arsenal of a software developer. Little things compose into bigger ones, but can be independently tested and improved without requiring unrelated por-tions of the software to be rewritten, so we like the idea of being able to compose.

What stops us from writing composable code are the intrusive patterns that make the code correct, resil-ient and performant. What we want to do is to take the little functions that perform the business logic of our program, and find clutter-free ways of composing them together, folding in the infrastructural patterns that we want to employ in the most inconspicuous way possible.

LEGO PROGRAMMING Consider the following indicative code in F#: …

let f: ‘a -> ‘b = …let g: ‘b -> ‘c = …let r x = g(f(x))

Here, the ``r`` function is a composite function of one argument ``x``, defined as the functionality rep-resented by applying ``f`` on the ``x``, taking its result and applying ``g`` on it.

This kind of chaining is so common that F# has a spe-cial way to represent it. We could write ``r`` as:

let r = f >> g

Now, if we follow the types of the inputs and results, we can quite easily derive the signature of the com-posite function ``r``.

let r: (‘a -> ‘c) = f >> g

We don’t even need to know what the ``f`` and ``g`` do; as long as they are functions without side-effects, we can use ``r`` whenever we need to call ``f`` fol-lowed by ``g``.

Now, as you would really expect from a language like F#, ``>>`` isn’t really a language construct, but a func-tion – a higher-order function which takes two func-tions as arguments and returns another function as a result.

You can think of the ``>>`` operator as being F# for “take the result of calling the first function and push it into the second”.

let (>>) : (‘p -> ‘q) -> (‘q -> ‘r) -> (‘p -> ‘r) = …

You can think of the ``>>`` operator as being F# for “take the result of calling the first function and push it into the second”. A very explicit implementation for it might be:

let (>>) f g = (function x -> let fx = f x g fx)

CONSTRUCTING TYPESA generic type can be thought of as a kind of function that constructs a resultant type given an argument type – in direct contrast with a “normal” function which constructs resultant values given values for arguments.

type M<’a> = …

6 1

Let’s consider what happens when our functions start using the generic types:

let f: ‘a -> M<’b> = …let g: ‘b -> M<’c> = …let r x = g(f(x)) // NO LONGER WORKS!

Straightforward composition breaks down, and we no longer can just take the result of one function and feed it into another function. But we can use the same trick that F# uses with the ``>>`` function and define something that will give us what we want.

let (>=>) : (‘p -> M<’q>) -> (‘q -> M<’r>) -> (‘p -> M<’r>) = …

This certainly has the right signature. But having the right signature isn’t enough – let’s write a similar implementation for it:

let (>=>) f g = (function x -> let mq = f x mq (>>=) g)

Well, this certainly works, but using some chicanery. We’ve introduced a new mysterious function ``>>=`` to do the dirty work for us. What does that look like?

let (>>=) : M<’q> -> (q -> M<’r>) -> M<’r> = …

Now the ``>>=`` function – pronounced “bind” – is necessarily closely tied to the generic type ``M``, since it needs to know how to access the internal portion of the generic type. It needs to know how to unwrap the value, and then call the second func-tion argument with it. Because that function returns a wrapped value, the bind function also returns a wrapped result.

HANDLING SIDE-EFFECTSWe can reason about simple function composition as long as the functions we are composing are pure – as in, they do not have side-effects. If any of the com-ponent functions throws an exception, for example, the whole composite chain will fall apart. If we were to make our functions truly composable even when there are side effects involved, we will have to modify our approach.

One way of doing this is to use generic types, and encapsulate the side-effecting, cross-cutting portions within a generic type.

Let’s consider a concrete example

let f1 : int -> int = … // may throwlet f2 : int -> double = … // may also throwlet f3 : double -> string = … // may also throw

Simple composition will result in a function that does not compose safely.

// this will blow up if anything throwslet r = f1 >> f2 >> f3 // : int -> string

Traditionally familiar ways of combining the functions breaks compositionality – we can’t simply combine any number of functions, for example. Also, this style is familiar because this is typically how code in imper-ative-style languages is written.

Now, let’s use our technique of combining with generic types:

And now, we have the tools we need to compose safely.

// traditional stylelet r f1 f2 f3 = function x -> try let f1x = f1 x try let f2x = f2 (f1x) try let f3x = f3 (f2x) f3x with | exn -> … // handle exception thrown by f3 with | exn -> … // handle exception thrown by f2 with | exn -> … // handle exception thrown by f1

// then, we write the ‘bind’ function for the Result<’T> typelet (>>=) (m : Result<’a>) (f : ‘a -> Result<’b>) : Result<’b> = match m with | Success x -> f x | Failure x -> Failure x

// first, we write a type which models the kind of behaviour /// we want to encapsulatetype Result<’T> = | Success of ‘T | Failure of Exception

let f1’ = safe f1 // int -> Result<int>let f2’ = safe f2 // int -> Result<double>let f3’ = safe f3 // double -> Result<string>

let result x = (f1’ x) >>= f2’ >>= f3’ // SAFE! WON’T BLOW UP!

// next, we write a function to “lift” a normal function // to a function that returns a wrapped type//// safe: (‘a -> ‘b) -> (‘a -> Result<’b>)let safe f = (fun x -> try Success (f x) with | exn -> Failure exn)

62

The first thing to notice is that because we have encapsulated our side-effects into the ``M`` generic type, the functions we are ``bind`ìng over are actu-ally side-effect free – at least insofar as they will not throw any exceptions. This allows us to compose them with impunity and reason equationally about their behaviour.

SYNTACTIC SUGARThis pattern is so powerful and useful in F# that there is some neat syntactic sugar that you can put around the composition, which makes it much easier to read and use. You’ll find these documented as Computa-tion Expressions, and they allow for some pretty look-ing code.

In this specific case, we can write the `àttempt`` computation expression as follows:

// define a ‘builder’ classtype AttemptBuilder() = member this.Bind (x, f) = x >>= f member this.Return (x) = Success x

// create a singleton instance with a descriptive name.let attempt = new AttemptBuilder ()

// Now, given some ‘unsafe’ functions…let one () : int = 1let two () : int = 2let three () : int = failwith “There is NO three!”let four () : int = 4

// …we can compose them safely using the tools we’ve built so far!let result = attempt { let! n1 = (safe one) () let! n2 = (safe two) () let! n3 = (safe three) () // this one will throw and the computation will end here let! n4 = (safe four) () // if the previous line is commented out, then we can compute this value, and yield a subsequent result!

return n1 + n2 + n4}

The `ÀttemptBuilder`` type is a special kind of F# class that allows us to override several functions; most minimally, we need to override ‘Bind’ and ‘Return’, and create an instance of this class with a descriptive name.

Once we do that, we can create a computation expression with the name of the instance, and use ``let!`` to perform the task of unwrapping the values for our use within the expression. The safe nature of the composition is evidenced by the fact that if any of the inner function invocations returns a failure value – because of, say, a thrown exception – then the expression itself short-circuits and returns the

failure value. If all the function invocations inside the expression succeed, then we are able to yield a value indicative of success.

SUMMARYWe started by considering the complexity of writing industry-strength code and the challenges associ-ated with providing infrastructural support in terms of exception handling, logging, retry-ing and so on. We noted that the current methods of coding up such requirements are labour intensive and difficult to extend or maintain.

We decided to explore the concepts of function com-position, and observed the mechanics of using higher order functions to compose simple functions of the type (‘a -> ‘b).

We then introduced the concept of a type construc-tor, and augmented our compositional patterns to handle functions of the type (‘a -> M<’b>). In doing so, we introduced the concept of Kleisli Composition, and implemented it in terms of a “bind” function spe-cific to the M type constructor.

We then worked through an application of these pat-terns to functions that threw exceptions, and discov-ered that monadic composition provided a way to safely compose impure functions by lifting them to safety and then composing monadically.

We then discussed the syntactic sugar that F# uses to support this form of composing functions, briefly introducing computation expressions.

We then covered, in very terse detail, the theoretical underpinnings of composition being a monoidal oper-ator over both types of functions; and enumerated the monad laws.

ACKNOWLEDGEMENTS• Brian Beckman’s “Don’t Fear The Monad”• Scott Wlashchin’s Railway Oriented Programming

Series, and Computation Expression series• Don Syme & Tomas Petricek’s Computation Expres-

sion Zoo

John Azariah has been writing software for over two decades now, and is now starting to get the hang of it! He has worked in several companies in the US, India, Singapore, and Australia; and now spends his work week shuttling between Melbourne and Sydney. He is an Azure MVP and a functional programming enthusiast.

63

THEORETICAL UNDERPINNINGSFor the most part, understanding the concepts above, and ensuring that we are managing side-effects in a way that allows us to com-pose pure functions is sufficient for writing clutter-free code.

However, there are rigorous mathematical underpinnings at the foundation of our methods. I’ll summarize them here:

Function Composition:• We have a set of things – functions of the form (‘a -> ‘b)• We have a binary operator called (>>), which has some properties

○ f >> g returns another function of the same form (‘a -> ‘b). We say that this means that the set is closed under the operation. ○ ((f >> g) >> h) is the same as (f >> (g >> h)). We can prove this by expanding out the values, and noting that they both are equivalent to (h(g(f(x))). This means that the group-ing order in which things are operated on is irrelevant. We call this property associativity.

• There is a special member of the set, called unit or zero, which when composed against any other member of the set, leaves it unchanged.

○ (f >> unit) = (unit >> f) = f

In mathematics, such a set with such an operation is called a monoid.

We can now safely say, with mathematical certainty, that the set of pure functions of the form (‘a -> ‘b) is a monoid under the composition operator, and thereby benefit from all the conse-quences of such a statement.

Kleisli Composition:• We have a set of things – functions of the form (‘a -> M<’b>)• We have a binary operator called (>=>), which also has the

properties of ○ Closure: f >=> g returns another function of the same form (‘a -> M<’b>). ○ Associativity: ((f >=> g) >=> h), (f >=> (g >=> h)) and f >=> g >=> h are all the same.

• There is a special member of the set, called unit or return, which when composed against any other member of the set, leaves it unchanged.

○ (f >=> return) = (return >=> f) = f

Now, we can also say that the set of pure functions of the form (‘a -> M<’b>) is a monoid under Kleisli Composition.

Monad Laws:If these following conditions hold, then we can say that M is a monadic type, and will safely support monadic binding and compo-sitions:• We have a type constructor M<’t>, and the related implementa-

tions of (>>=) and return• Given a wrapped value m of type M, then

○ m >>= return = m // aka ‘right unit’• Given an unwrapped value of x of type ‘a and a function f of

signature (‘b -> M<’c>), then ○ (return x) >>= f = f x // aka ‘left unit’

• Given a wrapped value m of type M, then ○ m >>= f >>= g = m >>= (fun x -> f x >>= g) // associativity

64

1 DAY WorkshopDESIGN AND IMPLEMENTATION OF MICROSERVICES Sam NewmanMicroservices Architecture

is a concept that aims to decouple a solu-tion by decomposing functionality into dis-crete services. Microservice architectures can lead to easily changeable, maintaina-ble systems that can be more secure, per-formant and stable.

2 DAYS WorkshopF# VIA MACHINE LEARNING Mathias BrandewinderMachine Learning and Functional Programming

are both very hot topics these days; they are also both rather intimidating for the be-ginner. In this workshop, we’ll take a 100% hands-on approach, and learn practical ide-as from Machine Learning, by tackling re-al-world problems and implementing solu-tions in F#, in a functional style.

Course EVOLUTIONARY DESIGN AND ARCHITECTURE FOR AGILE DEVELOPMENT Venkat Subramaniam

This is where the principles and the prac-tices we can learn and follow from evolu-tionary 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 in-sufficient design. Learn how to create prac-tical design that can efficiently balance the tradeoffs we face in architecting and de-signing software.

Course PROGRAMMING IN FUNCTIONAL STYLE Venkat Subramaniam“Functional programming,” yes, everyone’s talking about it. But why? What’s this new ex-citement about something that’s been around for a very long time in some esoteric languag-es. For one thing, most mainstream languag-es 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.

CourseREACTIVE PROGRAMMING WITH AKKAVenkat SubramaniamThe course has a good balance of interactive lectures and hands-on exercises. The at-tendees are expected to pair-up and work on the lab exercises. The instructor will assist the attendees as they work on the exercises.

CoursePROGRAMMING IN JAVA 8Venkat SubramaniamJava is arguably one of the most widely used languages. This popular language is going through a makeover. This will have a signif-icant 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.

CourseTEST-DRIVEN DEVELOPMENT

Venkat SubramaniamHoning Your Test Driven Design Skills. The course has a good balance of interactive lectures and hands–on exercises. The at-tendees are expected to pair–up and work on the lab exercises. The instructor will as-sist the attendees as they work on the ex-ercises. 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 TECHNIQUESRobert C. Martin

Test Driven Development (TDD) is one of the most profound Agile development practic-es. It has been adopted by nearly all the Agile methods and there is documented ev-idence that it has reduced defect rates by a factor of ten.

Course CORE SPRINGMårten HaglindIn this four–day boot-camp 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 in-tensely productive, hands–on setting.

Course FUNDAMENTALS OF ANDROID PROGRAMMINGWei-Meng LeeThis course covers the lat-

est version of Android using Android Studio. CourseLEARNING SWIFT PROGRAMMING Wei-Meng LeeApple announced the new Swift program-ming language at the Worldwide Develop-ers Conference (WWDC) 2014.

CourseFUNDAMENTALS OF IOS PROGRAMMINGWei-Meng LeeThe workshop will begin with the basic con-cepts such as Views, View Controllers, Pro-tocols and Delegates, as well as the tools that help you develop compelling iOS appli-cations – Xcode and Interface Builder.

CourseWEB DEVELOPMENT USING PHP AND MYSQLWei-Meng LeePHP is a server-side script language that is designed for dynamic web applications development. It is often used in conjunction with HTML and MySQL to produce dynam-ic web pages. In this course, participants will learn about the PHP language, as well as how it integrates with HTML to create dynamic web applications. In addition, par-ticipants will also learn how to use PHP together with MySQL databases to create data-driven web sites.

Workshops and Training

65

CourseADVANCED C++ PROGRAMMING AND INTRODUCTION TO C++11Hubert MatthewsThis course is designed to

introduce delegates to more advanced use of C++ as well as introducing the most com-mon parts of C++11.

CourseJAVASCRIPT FOR PRO-GRAMMERSChristian Johansen The JavaScript program-ming language is covered

in depth. Gain the necessary understanding of the language to work actively and ef-fectively 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 un-derstanding of how JavaScript really works.

CourseBDD - SPECIFICATION BY EXAMPLEGojko AdzicThis two day course teaches you how to apply

emerging practices for managing require-ments, specifications and tests in agile and lean processes to bridge the communica-tion gap between stakeholders and imple-mentation teams, build quality into soft-ware from the start, design, develop and deliver systems fit for purpose.

CourseHOW TO GET MORE VALUE OUT OFUSER STORIESGojko AdzicHave you struggled to split user stories into small but valuable chunks? Do you have prob-lems prioritising stories or getting a commit-ment from business stakeholders on what they want to achieve? Do you have issues deciding when a story is done or how many other stories you really need to achieve a business objective? Are you managing large amounts of stories that are problematic to estimate, prioritise or plan for? If so, join this interactive workshop and bring your product

owners and business sponsors to learn how to get the most out of user stories.

CourseANGULARJS FUNDAMENTALSScott AllenThe AngularJS framework allows us to build test-

able applications using the common web standards of HTML, JavaScript, and CSS. This course comprehensively demonstrates the features of AngularJS by building an ap-plication using directives, filters, routing, controllers, templates, services, and views.

CourseBUILDING APPLICATIONS WITH JAVASCRIPT AND NODEJS?

Scott AllenIn 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 applica-tions, as well as how to implement authen-tication and authorization.

CourseARCHITECTURE WITH AGILITYKevlin HenneyEvery system has an ar-chitecture, whether acci-dental 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 de-scribed 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 archi-tecture 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.

CourseAGILE DESIGN AND MODELING FOR ADVANCED OBJECT DESIGN WITH PATTERNSCraig Larman

This popular, high–impact, and hands–on course on mastering advanced object–ori-ented design (OOD) and design patterns (primarily the “Gang of Four” design pat-terns) 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, includ-ing 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 15. JuneCERTIFIED SCRUMMASTER (CSM) Daniel GulloThe Certified ScrumMaster® (CSM) Course is an entry

level certification course intended for anyone who wishes to learn about the Scrum frame-work so that they may be informed as their or-ganization moves through an Agile transforma-tion; especially, with Scrum practices. This two day course, not only provides the fundamental principles of Scrum, but also gives participants hands-on experience using Scrum.

Course 17. JuneCERTIFIED SCRUM PRODUCT OWNER (CSPO)Daniel GulloThe Certified Scrum Product Owner® (CSPO) Course is an entry level certification course intended for anyone who wishes to learn more about how product (and service) defi-nition result in increased value delivery and other benefits all throughout the Scrum life-cycle. Completion of this two day course re-sults in participants becoming certified as recognised Scrum Product Owners.

Contact us for in-house training and eventsprogramutvikling.no

66

Course 20. MayLEAN PRESENTATION SKILLSJessie ShternshusDo you know the way to best convey your ideas to your audience? Do you

have a great idea but don’t know how to put it together? In the world of Lean, your prod-uct is only as good as how you present it. Essentially, your product is your presenta-tion! Unfortunately, even if you have great content that people are interested in, if you fail to deliver your message, your product will fail as well. Building your talk using the Lean Start-up Model.

Course JAVASCRIPT AND IM-PORTANT JAVASCRIPT FRAMEWORKSSahil MalikJavaScript, the only lan-

guage that actually runs everywhere. From big servers in the cloud to tiny watches on your wrist. No wonder its gained such pop-ularitly. Spend 5 days with this powerful scripting language, and get up to speed with all the newest web technologies in popular use today.

CourseIDENTITY & ACCESS CONTROL FOR MODERN WEB APPLICATIONS AND APISDominick BaierWith 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 servic-es. In this new world we typically want to connect client platforms like iOS, Windows or Android as well as JavaScript-based ap-plications using frameworks like AngularJS.

Course OBJECT-ORIENTATED DEVELOPMENTEivind NordbyThrough discussions and a lot of practical training, this course conveys the

object-orientated way of thinking, rath-er 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 program-ming language.

Course PROGRAMMING JAVA STANDARD EDITIONEivind NordbyThis course is designed to give program-mers a solid grounding in the Java Pro-gramming language. Starting with the core syntax and OO concepts, it then progresses to covering class design, arrays and collec-tions, core libraries, exception handling, I/O and networking, JUnit testing an introduc-tion to Swing as well as the new Java fea-tures (the course is always up to date with the latest versions of Java SE).

Course C++ FOR EMBEDDED DEVELOPERSMike TarltonThis course introduc-es the C++ language for use on realtime and em-

bedded applications. The first part of the course focuses on the language itself, high-lighting 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 DE-VELOPMENT WITH TEAM FOUNDATION SERVERGáspár NagyThis two-day course pre-

pares software developers, testers and technology-oriented managers to use Mi-crosoft Team Foundation Server for devel-oping 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 DISTRIBUT-ED SYSTEMS DESIGN USING SOA & DDDUdi DahanDesigning large–scale dis-tributed 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.

Course C#.NET: DEVELOPMENT IN .NET WITH C#Arjan EinbuIn 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 devel-oper. You will learn how to develop both Win-dows (Windows Forms and WPF) and web ap-plications, libraries (.dll) and communication solutions with WCF.

CourseWEB DEVELOPMENT IN .NET - ASP.NET MVC , HTML5, CSS3, JAVASCRIPTArjan EinbuThis 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 con-trollers. On the client we’ll take advantage of HTML 5, CSS 3, and the best JavaScript frameworks, including jQuery, Modernizr, and more.

Course ARCHITECTING FOR CONTINUOUSDELIVERY AND ZERO DOWNTIMEAxel FontaineContinuous Delivery is all

the hype these days. This training makes it a reality. We start with an overview of what Continuous Delivery is and how it can help you. We then quickly dive into the details. You will learn what it takes to architect a Java application so that it can be delivered contin-uously into production, with code, configura-tion and database delta, multiple times a day, with Zero Downtime.

Course ELASTICSEARCHBOOT CAMPAleksander StensbyThis 2-day intensive course covers Elasticsearch in depth, focusing on how to

use Elasticsearch for search, data explora-tion and data aggregation. This course will provide you with the foundation to work ef-fectively with Elasticsearch and show that you don’t necessarily need a full Hadoop environment to make sense of your data.

COURSES continued

67

HOW TO FIND US – PROGRAMUTVIKLING MAIN OFFICE, OSLOProgramUtvikling AS is located in the IT-Fornebu technology park at Snarøya.

ADDRESSMartin 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

Entrance

Parking

Bus stop

ENROLMENT OPTIONSwww.programutvikling.no - [email protected] Tel.: +47 67 10 65 65 - Fax: +47 67 82 72 31

Course TEST-DRIVEN DEVEL-OPMENT FOR C OR C++ TRAININGJames GrenningThis training course helps you build knowledge, un-

derstanding and skill in the engineering prac-tices needed to build great C or C++ code. You learn how to build flexible and modular soft-ware with very few defects, software that can have a long useful life. We teach you how to prevent defects and how to keep code clean over years of evolving needs.

Course DEEP C: A COURSE FOR EXPERIENCED C AND C ++ PROGRAMMERSOlve MaudalIn this two-day course we will systematically go

through the fundamental building blocks needed to form the basis of a deep under-standing of the programming language C. We will also do exercises in groups and then discuss together what is good and bad code.

WorkshopREACT WORKSHOPEirik Langholm VullumReact is a JavaScript li-brary initially developed internally by Facebook/In-stagram and open-sourced

in 2013. It introduces a new way of thinking when it comes to building user interfaces in JavaScript. With its declarative style and virtual DOM-diffing algorithm it challenges established best practices. What does this mean for you? Faster, more maintainable ap-plications that are easier to test, debug and reason about. Don’t want to go all-in? Don’t worry. Dip your toes in. React facilitates be-ing used in as small or large a part of your ap-plication as you want to.

Containers are becoming the de-facto standard for deploying systems ranging from small wordpress sites to Google’s own clusters. This 2-day intensive work-shop provides an in-depth look at Docker and containers. You will learn how you can architect your applications to take advan-tage of a container-based solution. During this hands-on interactive workshop, del-egates will build and deploy applications using Docker. The workshop will cover the container lifecycle from development to production. The topics will include:

• Building and testing small, streamlined, containers

• Mutli-Container architecture • Auto-discovery architecture

• Monitoring containers and ensuring available

• Security concerns and considerations

At the end attendees will understand how to deploy and run containerized applica-tions in development and production and identify the benefits that containers can bring to systems’ architecture.

REQUIRED EQUIPMENT:Bring your laptop so you can use Docker and container based systems. We’ll provide Virtualbox and virtual machines in advance.

PREREQUISITES:Delegates should be comfortable working with a command line interface.

DEPLOYING DOCKER AND CONTAINERSINTO DEVELOPMENT AND PRODUCTION23-24. September with Ben Hall - 2 days workshop

About the instructor: Ben has done the rounds as a tester, developer, speaker, freelancer, startup ent repreneur and most recently work-ing at a startup invest-ment company in London. Ben is cur-rently working on his next startup venture.

68

Thursday night, June 18th we let Oslo Spektrum show you what it’s really built for – and turn up the volume for our lively lineup of perform-ers. We are happy to announce that both Ida Maria and Loveshack will be entering the stage in Oslo Spektrum this year.

Ida Maria is a Norwegian singer and songwriter, and is out with her newest album “Accidental Happiness”. She specializes in fiercely ener-getic and exciting alternative pop-punk music with catchy melodies and witty lyrics, like her hit song “I love you so much better when you’re naked” and the single “Oh My God” which featured a collaboration with rock legend Iggy Pop.

REVIVE YOUR INNER 80’S CHILDWe are also very proud to - once again - pres-ent Loveshack as part of our breath taking and spirit raising entertainment . Loveshack is easily the best cover band in Norway, and will take you back to the 80’s to keep you dancing all night.

Loveshack are, not surprisingly named after the massive B52’s hit released back in 1989. They put their own signature on the 80’s songs they cover in a big way, and create a magic retro atmos-phere most bands can only dream about. So revive your inner 80’s child for Loveshack, baby!

You don’t want to miss out on this years NDC Party!

NDC PARTY 2015

With an Oslo fjord cruise, grand music, exciting multiple dining choices andan intriguing expo area, NDC Oslo 2015 is destined to be an inspiring experience.

by Inger Renate M. Stie and Anette Aass Flølo

VISIT THE BUTCHER FOR LUNCHServing food throughout the con-ference, the Flying Culinary Circus bring you different and mouth watering dishes for breakfast, lunch and dinner. The concepts this year are more exciting than ever, and whether you’re a vege-tarian or a carnivore, there will be plenty of options for you.

THE NDC CRUISEWednesday June 17th @ 19.00Join us for an unforgettable cruise in the beautiful Oslo fjord. Tickets are available at ndcoslo.com

OUR PARTNERSStop by our partners as you move around the expo area, and get involved in exci t ing competitions, fun games and discussions.

© V

ebjø

rn O

lsen

© V

isitO

slo

© T

he F

CC

© A

SB

NDC PARTY 2015by Inger Renate M. Stie and Anette Aass Flølo

All you need to know about NDC 2015

SINCE 2008

practical information

Torbjørn Marø, Agenda committee

Torbjørn Marø is the CTO of PS WinCom a mobile communications company in Norway. He is a pas-sionate coder, and loves to learn and use new (and old) program-ming languages and technologies. As an active blogger he tries to share his excitement for software with anyone who’s willing to listen.“What I enjoy the most from a conference, apart from the great people and conversations, is often the more obscure topics. This year I’m looking forward to Gary Short’s troll hunt, Philip Laureano making a compiler, the talk on Mob Pro-gramming, and Yan Cui’s tour of the language landscape. As always NDC excites me!”

Torstein Bjørnstad,Agenda Committee

Torstein Bjørnstad is a consultant at Webstep focused on helping clients take use of modern web technology in order to provide rich and interactive user experiences to their users. He spends his spare time diving into and evaluat-ing new technologies in his many fields of interest. This is Mr Bjørn-stad’s second year in the agenda committee, and his focus is to represent the views of developers working with the .NET stack. “This year we received a record number of submitted abstracts on a lot of diverse topics, and thanks to this we have been able to produce what I feel is a very good agenda. We have many great names, and

a lot of interesting talks on top-ics ranging from microservices to troll hunting. Personally, I am really looking forward to our many archi-tecture talks! I hope you all enjoy this year’s NDC, I look forward to seeing you fill up Oslo Spektrum!”

Niall Merrigan,Agenda Committee

Niall is Managing Consultant with Capgemini Stavanger, He is also a Microsoft ASP.NET MVP, and gen-eral rugby nut (which means he shouts a lot). He has a passion for web technologies, security and whiskey which can lead to some interesting discussions. He can be found on twitter as @nmerrigan and hosts a blog at certsandprogs.com. “Oh boy that was tough! With great power comes great respon-sibility. Clichéd as it may seem, that is what is like when you sit on the agenda committee for NDC. I was extremely humbled to get the chance to go behind the scenes and help build the agenda for NDC. I am very happy to see a lot of security focused talks this year and I hope developers will come away from NDC this year with a lot of new ideas and techniques to add to their arsenal of tools.”

Liam Westley,Agenda Committee

Liam Westley is an application architect at Huddle based in Lon-don, with responsibilities includ-ing the mobile application archi-tecture 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 work-ing in television graphics has left him with a penchant for design and a concern for quality UX. “It is amazing how many proposals NDC receives when they issue a call for papers. It’s a real privilege to be on the agenda committee, get-ting a glimpse at what is currently exciting developers, even if it does involve being locked in a room by the NDC crew for two solid days. I’m really looking forward to the new speakers who will be in Oslo this year, including our youngest ever speaker, Sean Trelford.”

Bryan Hunter,Agenda Committee

Bryan Hunter is the CTO of Nash-ville-based Firefly Logic, and a functional programmer (Erlang, F#, and Elixir). He is a Microsoft MVP in F#, and founded the poly-glot functional programming group NashFP. Bryan volunteers much of his free time to promoting func-tional programming through com-munity building, developer events, and business-leader education. “It is business time for functional programming, and the goal of this track is to help you “make it real” in 2015 by bringing FP into your day job. For many attendees the benefits of F# are within reach, and we have assembled a stunning line-up of F# badasses.”

70

The NDC Oslo Team

Torbjørn Marø Torstein Bjørnstad Niall Merrigan Liam Westley Bryan Hunter

7 1

Arif Shafique,Agenda Committee

Arif has worked in the industry since 1997, and have for the past 9 years in Microsoft worked on everything that has been new and shiny, including apps for windows, WP, Xbox and Office365. Last year he started the IoT efforts inside his team where they are building competency on hardware along-side software and cloud. He is now working to educate and help devel-opers, startups and enterprise kick start their IoT efforts.”“This year’s NDC agenda looks very exciting and diverse. You will find talks from good old powerful C++ to lean and fun angular JS. And then there is the hardware stuff this year. Its exciting to see that hardware and software through the demand of IoT is now blending. But I believe in able to really create secure and useful IoT projects, software devel-opers must be part of the process. In that sense NDC 2015 is perfect place to kick start your IoT project”.

Olve Maudal,Agenda Committee

Olve Maudal works for Cisco Sys-tems where he is involved in devel-oping collaboration technology, in particular video conferencing prod-ucts and telepresence solutions. He loves to write code, but he is just as interested in how software is

developed as what it actually does. Main interests are C, C++, TDD, secure coding and software archi-tecture.“We have created a strong two day C++ track that we hope fits nicely into the new embedded and IoT track. This year you can learn more about details of the standard library, security, and modern devel-opment techniques in C++, just to mention a few things. Please note that there is also a two day pre-con-ference C++ tutorial that you prob-ably want to concider - Switching to C++11/C++14, Nico Josuttis.”

Mike Long, Agenda CommitteeMike’s specialties include coach-ing and mentoring teams to adopt modern technical practices in com-plex embedded and legacy develop-ment environments. Mike is active in the software community. As founder and organizer for the Oslo Embedded Software Meetup he has helped bring together passion-ate software craftsmen to share experience and skills. “With my background in low-level systems programming, I am delighted that NDC will host workshops and tracks on Embedded software and C++. Our community finally has a place to go to learn from each other and be amongst the leaders in our field. Devices are everywhere, software is in them, and it is changing our world!”

Kjersti Sandberg, Founder/Business Developer

Kjersti Sandberg is the founder of ProgramUtvikling AS, and has organized the NDC Conference from the very beginning. Her daily job is with the professional areas of sale, marketing and business development.

Jakob Bradford, General ManagerJakob is the general manager of the NDC conferences. He likes to be involved in everything and he really hopes this doesn’t make him a micro manager. He’s passion is business development and his dream is to bring the NDC confer-ences to all corners of the world.

Charlotte Lyng, Project ManagerCharlotte’s role is to be the main point of contact for speakers and partners as well as dealing with all the logistics such as speaker travel and speaker evening events for NDC Oslo and NDC London. She is also responsible for getting in articles for NDC Magazine, publish-ing content on NDC’s social media accounts and answer all enquiries in the NDC infobox.

Henriette Motzfeldt,Administration

Henriette’s is in charge of account-ing and administration. During NDC you will find her in the info booth.

Steinar Braaten, Web EditorSteinar is making sure that the NDC website is always up to date, and is publishing speakers and partners as soon as they are announced.

Kjersti Sandberg

Arif Shafique

Jakob Bradford

Olve Maudal

Charlotte Lyng

Mike Long

Henriette Motzfeldt Steinar Braaten

Ticket types Price

All Access Pass With Hotel NOK 26400 All Access Pass (Workshops + Conference) NOK 119003 Day Conference Pass With Hotel NOK 159003 Day Conference Pass NOK 11900 2 Day Conference Pass NOK 10500 1 Day Conference Pass NOK 8900 2 Day Pre-Conference Workshop Pass NOK 10500 1 Day Pre-Conference Workshop Pass NOK 8900 25% VAT will be added to all ticket types.

mix and match

be inspiredsign up now!

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

ndcoslo.com

SINCE 2008

@NDC_conferences #ndcoslo

2 DAYS OF WORKSHOPS3 DAYS OF CONFERENCE TALKS

Keynotes: Bruce Schneier and James Mickens

74

Meet the User Groupsat NDC Community

by Charlotte Lyng

NDC has invited some of the larger user groups to share their passion with the NDC crowd.The NDC community area has 7 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.

NDC Community Tuesday

Attend NDC Community Tuesday in Oslo Spektrum Tuesday 17.00. The event is free and several user groups have invited NDC speakers to host their meetups.

To learn more and sign up, go towww.meetup.com/NDC-Meetup/

75

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

BAKSIABaksia’s mission is to promote back end development. Our pres-entations and speakers focus on horizontally scalable solutions and the underlying frameworks, pro-gramming languages and para-digms. We are a fast growing com-munity of almost 600 members. In the three years since we started, 16 speakers have presented inter-esting topics at our meetings. We always start with food and bever-ages kindly provided by our spon-sors; Inmeta Consulting, Conax and Ardoq. NITH facilitate our meetings with central meeting venues in down town Oslo, close to public transportation.

BITRAFBitraf is a hackerspace / maker-space in Oslo, which is open to anyone 7 days a week. Come by if you are interested in program-ming, digital art, electronics, mill-ing and fabrication, free software, game development or other similar activities. Work own your projects in a social environment, host or attend a workshop, a game jam, hackathon, bug squashing party or a good old fashioned LAN party. Bitraf is completely user driven, so you decide what’s going on.

ANGULAR JS AngularJS Oslo meetup is a com-munity of web developers dedi-cated to one of the most advanced and hot discussed JavaScript frameworks ideally suited for cre-ating modern web and mobile applications. Community’s mission is to help web front-end devel-opers with selection of the best framework for their needs and to share knowledge, experience and best practices on it.

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

EMBEDDED SOFTWAREThis is a group for anyone inter-ested in embedded systems pro-gramming! If you love working on the low level, breathing life into hardware, and creating the next generation of devices this group is for you.

MOBILE MEETUPMobile Meetup Oslo is a com-munity dedicated to all aspects of mobile technologies world. We are about concepts, news, design, development, entrepreneurship in this rapidly evolving area. Our speakers and members are top mobile professionals and passion-ate enthusiasts who share their knowledge and experience as well as inspire you with fresh ideas about mobile devices, apps, frame-works, methodologies.

NDC MEETUPNDC Meetup host talks and work-shops with NDC trainers and speakers on a regular basis. We cover everything within the soft-ware industry.

Meet the following user groups at this year`s NDC Community:

76

Programming – the most important language

of the information ageby Tjerand Silde

I was 18 years old when I wrote my first lines of code. Despite my interest in science,I was not introduced to programming until I went to university. In retrospect, I think this is very sad,

because there is only a coincidence that has led to my discovery of a whole new world that I now have fallen in love with.

© O

llyy/

Shu

tter

stoc

k

77

The Teach Kids Code-movement (Lær Kidsa Koding) has experi-enced exponential growth since we started up for just a couple of years ago. New code clubs starts up all over Norway, and children of all ages are introduced to program-ming. For example, in Trondheim, we have 300 children attending the code club, every week. Con-sidering everything around us who are driven by electronics, all pro-fessions that rely on computers and all the time we spend playing games on tablets and phones. It is quite strange that most of us don’t know how anything works.

Fortunately, several countries have introduced programming as a compulsory subjects in primary

schools. Norway is still behind, but things have started to move. In January, the Minister of Local Gov-ernment and Modernisation, Jan Tore Sanner, visited the code club at Hofstad in Asker, we hope this visit will have positive outcome.Furthermore, Torgeir Waterhouse held the ending post on TEDxOslo 2015. His ten minutes on stage contained so many good points about why children should learn programming that TEDx chose to accentuate it as one of the best speeches in February. To this date, “Teach Kids Code” have been seen almost 13,000 times.

These are two of several events that have helped to increase awareness of programming in Norway. We also have the Hour of Code which in the recent years been held in December, where the goal is that all schools should set aside an hour of programming for all classes. This is a concept with increasing participation, and in 2014 there was almost 25,000 Norwegian kids that participated! This suggests that the important cultural change has started, and the Lær Kidsa Koding movement have grown so much that we have seen the need to take it to the next level.

In January 2015 Samsung and Lær Kidsa Koding(LKK) became part-ners, which gave us the oppor-tunity to hire a project manager to work full time to develop the movement further. This is where I come into the picture. Because of my background as a co-founder of the code club in Trondheim and leader in Vektorprogrammet, I got the great honor to dedicate all my time to LKK. The activity in the movement has increased signif-icantly and I meet almost exclu-

sively motivated children, grateful parents and committed tutors. I have no doubt that we are on track to revolutionize the modern knowledge society.

Despite all the activity around the country, both in terms of meet-ups, conferences and code clubs, one great event have been extra special. Namely NDC Jr. This is arranged for the third consecutive years, and the two preceding years we had 180 and 300 participants. The planning of this year’s event at Tuesday June 16th have started, and we hope to surpass the last two years. This year we will also have a special workshop for the most skil led youngsters. It is important to also challenge those who have taken the biggest steps. Until now, Lær Kidsa Koding’s main focus have been the beginners.

It is also important to emphasize that the code club is a venue for exploring, learning and creativity, not a place where an oracle tell you how everything works.

I have a deep desire to live in a society where all young people are able to influence their technologi-cal life. Don’t you?

«I think Lær Kidsa Koding movement is a great and important initiative, and I want to look at how we politicians can help to support such measures.»

JAN TORE SANNER

«I’m driven by the factand the knowledge and the hope and the dream that we

can empower kids with technology.»

TORGEIR WATERHOUSE

78

The capital of Norway

Oslo is a city full of contrasts. Its natural beauty, in combination with all the facilities of a modernmetropolis, adds to the charm of a city often described as ‘the world`s largest village’. The surrounding

countryside provides recreational opportunities for the city`s inhabitants and visitors all year round.

Oslo Opera House

The Royal Palace

The Town Hall Use the Oslo Pass on all public transport

© S

-F/S

hutt

erst

ock

© T

Tstu

dio/

Shu

tter

stoc

k©

TTs

tudi

o/S

hutt

erst

ock

© N

anis

imov

a/S

hutt

erst

ock

79

Oslo in numbers

• Total area: 454 square kilometres• Population (2014): 634,000 • Forest area: 242 km2• Park and sports arena area: 8 square

kilometres

• Lakes within the city limits: 343 • Islands within the city in the

Oslofjord: 40 • Length of the Oslofjord:

100 kilometres

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

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

MATHALLEN Mathallen Oslo is inspired by the great European food courts. Here you’ll find specialty shops, cafés and great places to eat. The court offers fish, meat, vegetables, baked goods, coffee – everything brought to us by the best suppliers and distributors of Norway, as well as some imported products. The atmosphere of the food court and its products reflects our passion for good food and beverages.

SCHOUSKJELLERENMIKROBRYGGERIImagine Norway in the time of the vikings: A dim, candle-lit vaulted hall where mead was swigged from goblets, resting on long rustic wooden tables, all the while a mas-sive fire roars away in the corner. Now replace the bearded barbari-ans with bearded Norwegian trend-setters, and the fermented honey water with in-house brewed beers and you have got the atmospheric setting of the schouskjelleren Mikro bryggeri brew-pub. The brew-ery is located underground in the cellar of the old Schous Brewery on Trondheimsveien.

HOLMENKOLLEN SKIJUMP A historic landmark in the Norwe-gian consciousness, Holmenkol-len embodies more than a century of skiing competitions. Inside the ski jump is the Holmenkollen Ski Museum, the oldest of its kind in the world. The museum presents over 4,000 years of skiing history, Norwegian polar exploration artifacts and an exhibition on snowboarding and modern skiing. The observation deck on top of the jump tower offers panoramic views of Oslo.

GRUNERLØKKAGrunerløkka is one of Oslo`s most popular boroughs. What started as a bohemian escape has turned into one of the most trendy parts of the city. Grunerløkka, com-monly referred to as ‘Løkka’, is know for its creative atmosphere and numerous little cafes, restau-rants and bars. The borough is also a popular shopping district with original design shops and many vintage stores.

THE NORWEGIAN OPERA & BALLET Opera fan or not, this building in itself is worth a visit. Oslo`s new Opera House is shaped lie an ice-berg coming out of the water, and is the first opera house in the world that let visitors walk on the roof. Learn more about the architecture, stagecraft, opera and ballet through a 50-minute guided tour.

FUGLEN Fuglen is a 3-in-1 coffee shop, cocktail bar and vintage design shop. Fuglen (“the bird”) opened as a coffee shop in 1963, and high-quality coffee and tea is still an important part of the business. Fuglen’s trained basistas serve all kinds of espresso drink. In the evening it becomes a classic cock-tail bar. Fuglen’s bartenders mix both traditional and innovative cocktails made from fresh ingre-

dients. Both during day and night Fuglen is also a vintage design shop. Everything in the bar is for sale: chairs, tables, lamps, plates, glasses and nicknacks!

THE VIGELAND PARKThe park is a must-see in Oslo. The famous park is filled with 192 sculptures bronze and granite sculp-tures, far stretching lawns and long straight avenues bordered with maple trees. On a nice summer day, the park is full of people here you can go for a run, walk the dog, have a picnic or barbecue, play bad-minton or just do some sunbathing.

HOW TO GET AROUND IN OSLOThe Oslo Pass gives you free entry to more than 30 museums and attractions, free travel on all public transport, free entry to out-door swimming pools, discount on sightseeing, concert tickets, bike rental and special offers in restaurants, shops entertainment and leisure venues. You can decide whether you want a card that is valid for 24, 48 or 72 hours.

VISIT BYGDØY Bygdøy is a peninsula on the western side of Oslo, Norway and belongs to the borough of Frogner. Bygdøy has several museums, like the Kon-Tiki Museum, which shows all year long the legend-ary expeditions of Thor Heyer-dahl, the Norwegian Museum of Culture History, The Viking Ship Museum and the Norwegian Mar-itime Museum. Bygdøy is one of Norway’s oldest cultural land-scapes with a rich history. Bygdøy has beautiful parks and forests and some of Oslo’s most popu-lar beaches. Bygdøy is accessible by bus, bike or it can be reached by the local public ferry depart-ing from Aker Brygge every 30 minutes.

.NET Framework Agile Architecture Big Data C++Cloud Database Design Devops EmbeddedFun Functional Programming IoT JavaScript Microsoft Mobile People Programming Languages Search Security Testing UI UX Web

Time-slots Room 1 Room 2 Room 3 Room 4 Room 5 Room 6 Room 7 Room 8 Room 9 Workshops

09:00 - 10:00

Keynote - Data and Goliath: The Hidden Battles to Collect Your Data and Control Your World

Bruce Schneier

10:00 - 10:20 Break

10:20 - 11:20

This is not the search you are looking for

Duplicating data or repli-cating data in Micro Services

TBA The New Ja-vaScript: ES6

Practical CSS tips & tricks for backend developers

The Art of Software Gardening

Linux Device Driver Best Practices

The Real Price of Shared Point-ers in C++

Functional Programming and Lean

Toby Hender-son

Dennis van der Stelt

Damian Edwards

Rob Eisenberg

Alex York

Patroklos Papapetrou

Bill Gatliff Nico Josuttis Bryan Hunter

11:20 - 11:40 Break

11:40 - 12:40

Approaches to multi-lingual text search with Elasticsearch and Lucene

Microservices, cutting through the Gordian Knot

A Lap Around .NET 2015

Asynchronous generators and promises in ES6

Developing interfaces — Why developersare the new designers

No Estimates, Let's Explore the Possibilities

Faking and Mocking Legacy Embed-ded C

Fundamentals of Type-De-pendent Code Reuse in C++

A tour of the language landscape

Itamar Syn-Her-shko

Ian Cooper

Anthony D. Green

Francis Paulin

Martin Jensen

Woody Zuill

James Gren-ning

Mark Isaacson Yan Cui

12:40 - 13:40 Lunch

13:40 - 14:40

IMDB showdown - comparing OrigoDB, Redis and SQL Server Hekaton

Continuous Delivery for Architects

What’s new in ASP.NET 5 and MVC 6

Async and Streaming JavaScript, We're All Doing it Wrong!

‘Don't Make Me Feel Stupid’ – A. User

Lightning Talks Introducing Bluetooth Low Energy

When order does not matter

Robert Friberg

Neal Ford

Jon Galloway and Damian Edwards

Matthew Podwysocki

Liam Westley

Per Thorsheim, Fredrik Johnsson, Pete Smith, Ashfaq Ahmed and Meg Gotshall

Eirik Midttun Bartek Szurgot

14:40 - 15:00 Break

15:00 - 16:00

A guided tour of the BigData technologies zoo

The Actor Model: Building Hyper-Scale Distributed Systems Using Orleans

.NETCore Blimey!

All Your Tests Are Belong to Us

Form with Function: Add-ing Behavior with CSS

Anti-fragile and feedback. Try-ing to make up for the failures of "agile."

How TDD and SOLID principles can improve your HW abstraction

Dealing with noexcept in the C++ Standard Library

Learning from Haskell

Itamar Syn-Hershko

Patriek van Dorp

Matt Ellis

Rachel Appel

Tim G. Thomas

Andy Hunt Tore Martin Hagen

Nico Josuttis Venkat Subra-maniam

16:00 - 16:20 Break

16:20 - 17:20

To NoSQL or Not to NoSQL, That Is the Question

50 Shades of AppSec

Applying S.O.L.I.D. Princi-ples in .NET/C#

Seriously, you should start testing that JavaScript code

Front-endFun with Sass and Coffee

Ads in Mobile Apps and Games 101

BDD for Embedded Systems

History and Spirit of C and C++

F# and games: picking up Steam

David Ostro-vsky

Troy Hunt Chris Klug

Kuba Walinski

Dylan Beattie

Alan Mende-levich

Oscar Hell-ström

Olve Maudal Andrea Mag-norsky

17:20 - 17:40 Break

17:40 - 18:40

Modelling complex game economy with Neo4j

This is Water Omnisharp: .NET sans Microsoft

JavaScript Forensics

Designing and Programming Accessible Website and App UIs

Shazam mobile apps - data driven project management

Monitoring Sensor Data in RealTime over Azure

Performance of STL containers

Type-Driven Development

Yan Cui Neal Ford Mathew McLoughlin

Todd H Gardner

Rachel Appel

Tomasz Kus-trzynski

Uffe Björklund

Hubert Mat-thews

Mark Seemann

PROGRAM – Wednesday Per April 2015 - Subject to change

80

81



09:00 - 10:00

Principles Of Microservices

TBA Up and Run-ning with ASP.NET on Linux

Declarative REST: State Machines for the Web

Building 3D simulators for oil & gas

Perceived speed is real speed

Video Capture and Color-spaces

Hafslund AMS: Drinking from the firehose at a large Inter-net-of-Things project

Elixir

Sam Newman

Udi Dahan Mark Rendle

Einar W. Høst

Felix Gorbat-sevich

Fredrik Johns-son

Hans Verkuil Jon Andreas Pretorius and Simen Som-merfeldt

José Valim

10:00 - 10:20 Break

10:20 - 11:20

Typical Pitfalls in Agile Software Development

Resolving Conflicts in Collaborative Occasionally Connected Mobile Apps

What’s new in Visual Studio 2015, ALM + ASP.NET 5: Next Level Development

Succeeding in Failing

Desktop appli-cations using Chromium and Node.js

Don't demo facts. Demo stories!

Continuous Delivery of Embedded Systems

The Set of Natu-ral Code

Event Sourcing and DDD with F#

Jutta Eckstein

Michael L Perry

Adam Cogan

Darrel Miller

Torstein Bjørnstad

Tudor Girba Mike Long

Mark Isaacson Jérémie Chassaing

11:20 - 11:40 Break

11:40 - 12:40

The State of DevOps in Win-dows Land

SOLID Architecture in Slices not Layers

Migrating your API from Web API 2 to MVC 6

High Perfor-mance in the Critical Render-ing Path

TBA What business software developers can learn from game developers

FPGAs - a 1000x performance increase. How? What? Why?

Test Driven Development in C/C++

The Phoenix Framework

Jon Arild Tørresdal

Jimmy Bogard

Filip W

Nicolas Bev-acqua

Greg Young Adam Beres-Deak

Espen Tallak-sen

James Gren-ning

Chris Mccord

12:40 - 13:40 Lunch

13:40 - 14:40

Automating legacy envi-ronments with Azure

Loosely coupled appli-cations with MassTransit and RabbitMq

The Power and Practicalities of Immutability

Real Communi- cation with Real People in Real Time with WebRTC. For Reals.

Securing Web APIs – Patterns & Anti-Patterns

Lightning Talks Testdriven C++ with Catch

C++ on the Web: ponies for developers without pwn’ing users

Enterprise Tic-Tac-Toe -- A functional approach

Agile 1's game

David Lindblad

Roland Guijt Venkat Subra-maniam

Devin Rader

Dominick Baier

Sean Trelford, Ronald Mavarez, Martin Gravråk, Glenn F. Henriksen and Stian Veum Møllersen

Phil Nash

JF Bastien

Scott Wlaschin

Seb Rose

14:40 - 15:00 Break

15:00 - 16:00

Continuous Delivery - the missing parts

It's all mes-sages now: where are my abstractions?

Making .NET Applications Faster

Tomorrow's World of Web Development

Authentication and authorization in modern Java- Script web applications – how hard can it be?

How to turn software into competitive business advantage

Memory Ac-cess Ordering in Complex Embedded Systems

Building IoT Device Applications in JavaScript and C++

Grokking Erlang OTP

Paul Stack Matt Barrett

Sasha Gold-shtein

Steve Sander-son

Brock Allen

Gojko Adzic Chris Shore Günter Obiltschnig

Martin Logan

16:00 - 16:20 Break

16:20 - 17:20

The elephant in the room: Continuous Delivery for Databases

Modern architectural patterns for the cloud

Code Gems From the Rosyln and .NET Source Code

Reactive Programming Demystified

Hacking .NET(C#) Applications: Defense / Offense 103

Deliberate creativity

Embedded Linux develop-ment using the Yocto Project

Encryption in C++

~Machine learning F#

Alex Yates

John S Azariah and Mahesh Krishnan

Scott Allen

Matthew Podwysocki

Jon McCoy

Andy Hunt Isak Styf Jens Weller Mathias Brandewinder

17:20 - 17:40 Break

17:40 - 18:40

Running Docker and Containers in Development and Production

Troll Hunting on the Internet

Ten simple rules for creating your own compiler on the CLR

Taking other peoples money: A guide to on-line payments

Data explo-ration and analytics with elasticsearch

Getting the first PR into .NET and other tales from an OSS contributor

IoT: babbling with bits and bytes

Functional C++

Ben Hall

Gary Short

Philip Laureano

Ben Cull Aleksander Stensby

Adam Ralph Suz Hinton

Kevlin Henney

18:40 - 19:00 Break

19:00 - 19:30 Not Even Close: The State of Computer Security. James Mickens

19:30 - 00:00 Party

PROGRAM – Thursday Per April 2015 - Subject to change

81

82



09:00 - 10:00

Continuous De-livery Patterns for Cloud-based Applications

TBA Swift: Apple's New Programming Language for iOS and OS X

Aurelia: Next Generation Web Apps

Boosting secu-rity with HTTP headers

Standing on a Beach, Staring at the C

AWS vs. Azure - architectures and choices

Multicore Software Development on ARM

Nano-services (functional composition)

Get Unblocked

Mitch Denny

Udi Dahan Sasha Gold-shtein

Rob Eisenberg André N. Klingsheim

Kevlin Henney

Michele Leroux Bustamante and Lynn Langit

Chris Shore Phillip Trelford Denise Jacobs

10:00 - 10:20 Break

10:20 -11:20

Advanced Con-tinuous Delivery Scenarios

The rest of ReST

Universal Windows Apps – Develop for all Sizes

ReactJS A security testers toolkit

Engagement techniques. How to get people engaged and motivated?

Get more than a cache back! The Microsoft Azure (Redis) Cache

Beer analysis using Kibana 4 and Elastic-search

TBA The Dark Artof Autonomy

Jeff French Dylan Beattie

Lars Klint

Eirik Langholm Vullum

Niall Merrigan Anna Danes Maarten Balliauw

Christoffer Vig

Tomas Petricek Carl Smith

11:20 - 11:40 Break

11:40 - 12:40

How do you scale a logging infrastructure to accept a bil-lion messages a day?

Learning Client Hypermedia from the Ground Up

Making Hacking Child’s Play

Lifestyles of the rich and frameworkless

Going beyond OWASP

Removing barriers

Make it Faster - Lessons Learned from Benchmarking NoSQL on the AWS Cloud

TBA Let’s Start an Epidemic

Paul Stack

Mike Amund-sen

Troy Hunt Pete Smith Barry Dorrans

Hadi Hariri Lynn Langit

Irina Guberman Doc Norton

12:40 - 13:40 Lunch

14:40 - 15:00

Why monitoring sucks, and how to improve it

Crafting Evolvable Web API Rep-resentations

Making 2D Games that Run Everywhere using C# and CocosSharp

Real-time, offline- capable, noBackend web apps with Firebase

Mob Program-ming, A Whole Team Approach

Microsoft Azure Web Jobs - the new way to run your workloads in the Cloud

Lightning Talks Metaprogram-ming Elixir

Workshop

Pavlo Baron Darrel Miller

James Monte-magno

David Ed Mellum

Woody Zuill

Magnus Mårtensson

Claus Asbjørn Sørensen,Trond Marius Øvstetun,Alex Yates, Michał Sliwon and Todd H. Gardner

Chris McCord Denise Jacobs

14:40 - 15:00 Break

15:00 - 16:00

Knowledge is power! The guide to measure what matters.

595 billions income - untouched by human hands

TBA Getting started with Meteor

.NET Rocks Panel on Appli-cation Security

Avoid the Bug as Task anti-pattern

Cloud-Scale Event Process-ing with the Reactive Exten-sions (Rx)

Workshop

Mark van Straten

Trond Arve Wasskog

Greg Young Kuba Walinski

André N. Klingsheim, Barry Dorrans, Troy Hunt, Niall Merrigan, Carl Franklin and Richard Campbell

Martin Hinshel-wood

Matthew Podwysocki

Denise Jacobs

16:00 - 16:20 Break

16:20 - 17:20

DevOps Your-self: Fast-Track Your Windows Development Environment Setup with Chocolatey and Vagrant

Everything I Know About Computers, I Learned From the Movies

Xamarin.Forms: Native iOS, Android, and Windows Phone apps from ONE C# Codebase

ng-owasp: OWASP Top 10 for AngularJS Applications

Browser-cep-tion: Building our own browser with CSS/HTML and Node.js

How to build and be a part of a highly efficient team

Evolving architecture for API delivery on Azure

F# as our day job by 2016

Justin James Mark Rendle James Monte-magno

Kevin Hakan-son

David Ed Mellum

Kjell Ljøstad Harald Schult Ulriksen

Tomas Jansson

PROGRAM – Friday Per April 2015 - Subject to change

One day of Internet of Things

15. OCTOBERRadisson Blu Scandinavia Oslo

One day of Internet of Things

15. OCTOBERRadisson Blu Scandinavia Oslo internetofthingsday.com

CONNECTING PEOPLE AND THINGS - BRIDGING BUSINESS AND TECHNOLOGY The first One Day of Internet of Things Conference was held in November 2014.

The date for this years IoT conference is set to 15. October 2015 at Radisson Blu Scandinavia Hotel.

BECOME A PARTNERA partnership includes: Exhibitor space including 1 table and 2 chairs • Your logo on our website, in advertising material

and in the conference program • Your logo in the profiling decor and exhibition space during the conference • 2 conference tickets. Access to discounted partner tickets • Total cost: 20 000 NOK + VAT

CALL FOR PAPERS The Call for Papers deadline is 1 August 2015. Make sure you don’t miss the deadline if you would like to speak.

Submit your papers to [email protected]

NDC Oslo 15-19 june 2015ndcoslo.com

One Day of Internet of Things 15 October 2015internetofthingsday.com

NDC London 11-15 January 2016ndc-london.com

Upcoming NDC events

Returadresse: ProgramUtvikling AS. Postboks 1, 1330 Fornebu

ndc magazine- ndc oslo 2015 edition

Documents