Monday, 31 October 2016

Rearchitect your code towards async/await - Daniel Marbach

The die is cast. Your business- and infrastructure logic will need to move gradually to asynchronous code. Changing large code-bases to async/await seems like a monumental effort. It doesn't have to be! In this talk, I show you a four-phased approach to evolving your code-base towards async/wait. In the identification phase, we classify the components which would benefit from async/await. In the exploration phase, we discover potential road blockers which might hinder the async/await adoption.
In the obstacle phase, we learn to redesign parts of the code to remove the previously identified road blockers. In the bring-it-together phase, we gradually move the components which benefit the most from async/await to a full asynchronous API. Small steps. No Big Bang. Join me on a journey towards async/await and learn to leverage the power of asynchronous code to embrace the cloud-first APIs of today and tomorrow.

Source: NDC

Sunday, 30 October 2016

Manage Yourself! - Jurgen Appelo

Manage Yourself!

Manage Yourself! is about concrete management advice for all workers. Practical things that people can do next Monday morning, in order to grow an organization that is fit and healthy. And not only managers, but everyone who is concerned about the organization. Because, management is too important to leave to the managers. The whole organization should feel responsible for a better organizational culture.

How can we measure team performance?
How can we pursue career paths?
How can we replace performance appraisals?
How can we motivate our ourselves?

Nowadays, all knowledge workers are expected to be “servant leaders” and “systems thinkers”. In this session, you will learn how you can do that concretely. As a result, you will have better management with fewer managers.

Source: Optional Conference

Saturday, 29 October 2016

Sherlock Homepage - A detective story about running large web services - Maarten Balliauw

The site was slow. CPU and memory usage everywhere! Some dead objects in the corner. Something terrible must have happened! We have some IIS logs. Some traces from a witness. But not enough to find out what was wrong.
In this session, we’ll see how effective telemetry, a profiler or two as well as a refresher of how IIS runs our ASP.NET web applications can help solve this server murder mystery.

Source: NDC

Friday, 28 October 2016

Promise to Not Use Promises: Observables in - Brian Holt

ES6’s native support for Promises landed just late enough for Brian Holt to realize that he should never use them. He’ll explain how Observables, a spec that forms the basis of RxJS and is in ongoing discussion to perhaps land in, made him see the light. Brian outlines what Observables are, how to use Observables in code today using RxJS, how Observables can totally eclipse the use of Promises, and what the state of the Observable spec is for native JavaScript. Participants will leave with the knowledge of a forthcoming tool they can add now to their toolbox.

Source: ABBDevDay

Thursday, 27 October 2016

Agile Leadership – A trip through 2.5 million years - Louise Elliott

What does human evolution teach us about how we should lead teams in the 21st century? This talk takes a journey covering the last 2.5 million years from a hunter and gather lifestyle to the creation of agriculture and through to the industrial revolution, in order to understand the influences which still affect us today. It asks questions such as “Why are 30% of Fortune 500 CEOs so tall?” and “Can you tell a person’s job just by looking at their face?”. It also delves into the different strategies which chimpanzees use to become the alpha male and considers whether any of them would be useful in the human world.

Source: NDC

Wednesday, 26 October 2016

Top 20 tools and tips that make me a better developer - Roy Osherove

In this session you will learn about the tools I use every day to speed up my work, to help me think better, to help me plan better and execute faster, to find errors faster, to automate easier and to be better at what I do. Bring a pen and paper - you'll need them!

Source: Oredev

Tuesday, 25 October 2016

Cross-Platform Desktop Apps with Electron - David Neal

Cross-Platform Desktop Apps with Electron - David NealWould you like to leverage your HTML, CSS, and JavaScript skills to build cross-platform desktop applications? Electron is an open source application shell created by GitHub, designed to make building great desktop applications easy.
You may have already experienced Electron using applications such as Atom, Slack, or Visual Studio Code. In this talk, you will learn its features, how to quickly get started, and tips from my experience building Electron applications.

Source: NDC

Monday, 24 October 2016

Metrics Driven Development - Sam Elamin

In this talk Sam Elamin will relate his real life experience working on a distributed system dealing with £100,000 worth of transactions every hour. Sam will cover monitoring and how to develop your features based on how your customers use your platform and, most importantly, business metrics.

Source: Dev Day

Sunday, 23 October 2016

Event Sourcing & Immutable infrastructure - Greg Young, James Nugent

--Immutable Infrastructure with Packer and Terraform
In this webcast we will look at the basics of using Packer to build machine images for a variety of clouds, and using Terraform to provision cloud resources, in order to declaritively manage infrastructure in an immutable fashion. We'll also look at common patterns for good factoring of infrastructure-as-code which allows application teams autonomy for their services, while retaining central operations control of shared infrastructure.

--Event Sourcing
Looking at mature domains it is odd that almost none have a concept of current state but instead are built off a set of facts that occurred; is your bank balance a column in a table? This is not by accident and there are many benefits to having this viewpoint of a system both from a business and a technological viewpoint. In this talk we will look at what cqrs (command and query responsibility segregation) and event sourcing are.

Source: BuildStuff

Friday, 21 October 2016

19 1/2 Things to Make You a Better Object Oriented Programmer - Greg Young

This session will introduce a series of things that will make you a better object oriented programmer and more importantly give you explanations on the thought processes behind the ideas.

Source: oredev

Thursday, 20 October 2016

Choosing a JavaScript Framework - Rob Eisenberg

In the last couple of years there has been an explosion in JavaScript frameworks. How is a developer or business to make a wise choice? What are the advantages, trade-offs and differences? In this talk we’ll compare and contrast six popular front-end frameworks: Angular 1, Angular 2, Polymer, React, Ember and Aurelia. We’ll look at the same “Hello World” example in each framework so we can see, side-by-side, the differences in development strategy and philosophy.
We’ll also discuss how these frameworks stack up against a set of both technical and non-technical key evaluators so that you can get beyond the hype and finally make a solid technical and business decision.

Source: NDC

Wednesday, 19 October 2016

Specification By Example - Gojko Adzic

The owner of this video has set domain restrictions. You can watch it here.

About Gojko Adzic

Gojko is a strategic software delivery consultant who works with ambitious teams to improve the quality of their software products and processes.

He specialises in Lean|Agile quality improvement, in particular Agile testing, Specification By Example and behaviour-driven development.

Gojko’s book Specification By Example was awarded the number two spot of the top Agile books for 2012 and won the Jolt Award for best book of 2012. In 2011, he was voted by peers as the most influential Agile testing professional and his blog won the UK Agile award for the best online publication in 2010.

Source: Assurity Consulting Vimeo

Tuesday, 18 October 2016

Practical Microservice security - Laura Bell

Moving away from complex monolithic architectures has a range of well documented benefits but also dramatically changes how we have to think about security. How can we make the most of these new approaches without introducing risk to our applications and organizations?
In this session we take a look at securing microservice architectures and discuss tools, techniques and considerations to achieve this. Based around real world examples and demonstrating both attacks and defence techniques, we will learn how to be bad to our systems in the name of being good.

Source: ndc vimeo

Monday, 17 October 2016

Security and Authorization in .NET Core World - Barry Dorrans

ASP.NET Core has presented us with the opportunity to improve our security store, throw away or improve on of the mistakes of the past. ASP.NET now has a new authorization stack and different ways to load balance cryptographic keys. This session will demonstrate the new features and walk you through building a flexible authorization system to help you secure your web apps.

Source: Channel9

Sunday, 16 October 2016

The Technical Debt Trap - Doc Norton

Technical Debt has become a catch-all phrase for any code that needs to be re-worked. Much like Refactoring has become a catch-all phrase for any activity that involves changing code.
These fundamental misunderstandings and comfortable yet mis-applied metaphors have resulted in a plethora of poor decisions. What is technical debt? What is not technical debt? Why should we care? What is the cost of misunderstanding? What do we do about it? Doc discusses the origins of the metaphor, what it means today, and how we properly identify and manage technical debt.

Source:  ndc video

Saturday, 15 October 2016

The Next Wave of Mobile Apps: TypeScript 2, Angular 2 + Ionic 2 - Ryan Salva

For users already familiar with Ionic and Apache Cordova, this intermediate to advanced level session will explore some of the new design patterns, development workflows and... yes, even quirks in the next generation of JavaScript frameworks. You'll learn how to bend the toolchain to your will to accomplish some truly amazing feats of code.

Source: channel9

Friday, 14 October 2016

Agile Metrics - Beyond burn up/down’s onto Metric Driven Coaching - Troy Magennis

How can metrics be used safely in coaching Agile teams? The classic Goldratt quote 'Tell me how you will measure me and I will tell you how I'll behave' signals the danger of using metrics to manage or motivate employees. This session shows and suggests approaches to Agile metrics that avoid the common pitfalls and shows some practical dashboards and the resulting chaos or calm they caused. This talk will show actual dashboards and metrics from actual industry engagements. It will explain how to safely capture and display these and how to teach an organization to see and understand its data. Be warned though, the techniques shown go beyond burndowns charts and cumulative flow diagrams.


  • The dangers of managing by metrics
  • Balanced approach to metric dashboards (less is more, but too little is disastrous)
  • Digital storytelling and patterns (examples of good and bad dashboards)
  • Coaching advice and dashboards
  • Visualizations of the edge – attention grabbing ideas for action
Source: video, description

Thursday, 13 October 2016

Build Real-Time Websites and Apps with SignalR - Rachel Appel

If you've ever wanted to build a highly responsive app that leverages a real-time communications library, then SignalR is for you! Real-time Web functionality is the ability to have the server push messaging aggressively to the client, rather than relying on the client to make multiple and frequent requests. SignalR is a set of ASP.NET server and client libraries that you can use to build real time, scalable, Web sites and apps. You can use SignalR in both enterprise and consumer apps, and across platforms. This session covers what you need to know to build a SignalR app that connects multiple clients instantaneously.

You will learn:

  • To use the SignalR libraries
  • About polling and real-time development techniques
  • About cross platform client connectivity

Wednesday, 12 October 2016

How to build .NET Microservices - Richard Banks

Thanks to organisations like Netflix, and the need to develop solutions that scale well in the cloud, microservices have become the hot new topic. Yet, for all the talk, there are few practical examples of how you actually build a microservice in .NET.
It's time to fix that littlle oversight as we show you how you can build a microservices based solution using .NET, and a number of open source tools (EventStore, RabbitMq and Redis to name a few).
You'll also get to understand the pros and cons of a microservices solution and consider how a microservices approach might impact how you and your team relate to your customers.

Source: ndc vimeo

Tuesday, 11 October 2016

Deep Dive into ASP.NET Core - Daniel Roth

In this talk we will dive deep into the guts of ASP.NET Core. We'll look at how the HTTP request pipeline is constructed and how HTTP features are exposed. We'll look at how ASP.NET Core hosting works and what best practices are for deploying and monitoring your application. We'll look at the guts of MVC and how it interacts with the core routing infrastructure.

You will learn:

  • About the ASP.NET Core HTTP pipeline
  • About ASP.NET Core hosting best practices
  • About ASP.NET Core MVC and its relationship to routing

Source: Channel9

Monday, 10 October 2016

Secrets of the Chrome Developer Tools - Patrick Dubroy

The Developer Tools built into Google Chrome provide powerful ways to understand, debug, and profile web applications. Most developers are familiar with its basic inspection and debugging tools, but some of its most valuable features, like the timeline and memory analysis tools, are lesser known. This talk will provide an overview of the Chrome dev tools and an in-depth demonstration of some of the lesser-known features.

Source: video, description

Sunday, 9 October 2016

Deploying Docker Containers on Windows Server 2016 - Ben Hall

Docker has changed the way we deploy applications onto Linux and ARM based systems. Windows Server 2016 introduces first class container support to the Windows Kernel.
In this session Ben will explore how Docker and Windows will work together, the impact it will have and how you can get started.
Key talking points will include:
- Deploying applications using Windows containers
- Managing Windows containers using tools from the Docker ecosystem
- Combining Linux and Windows containers
- Difference between Nano containers and Server Core containers
- Why Hyper-V isolation exists
- Windows Container Security Model
At the end attendees will understand how containers on Windows will work and the problems they’ll solve.

Source: ndc vimeo

Saturday, 8 October 2016

UX in an Agile Process - Janne Jul Jensen

Originally, the field of usability and interaction design was slow, cumbersome and costly. These were some of the reasons that it was not adopted very fast among practitioners. However, recent years a lot of the methods and techniques have been adapted to better fit the fast moving development processes that are predominant in software companies today. But what do you do when you can't include users because of NDAs? How do you handle the fierce security demands, that are part of your project? Does your customer really know their users, or do they only think they do? And when you have a deadline, how do you avoid UI slowing your progress? This talk is a case story of how UX was included in the agile development process that resulted in the first Danish mobile bank app: Danske Banks mobile banking app.

 Source: video, description

Friday, 7 October 2016

Software that Fits in Your Head - Dan North

Software gets complicated fast. Most of good architecture and design practise is about trying to slow the rate at which software gets complicated. You can't stop it, it's a form of entropy. You can only slow it down and do your level best to stay on top of things.

One way to manage the mess is to maximise the likelihood that everyone knows what's going on in the codebase. This requires two things: consistency and replaceability.

Consistency implies you can make reasonable assumptions about unfamiliar parts of the application. Replaceability means you can kill code easily and replace it with something better.

Dan North argues that code should either be new enough that someone remembers writing it, or well-enough established that everyone knows how it works. It's code in that awkward middle stage, between brand new and part-of-the-furniture, that gets forgotten about and starts to smell.
If code is going to die it should die quickly. If it is going to stick around it should be stable.

In this talk, Dan describes a model for thinking about the age of code and argues for replaceability as a first class concern. He also discovers that if you optimise for both replaceability and consistency you can end up with something that looks a lot like microservices.

Source: video, description.

Thursday, 6 October 2016

Debugging Tips and Tricks for .NET Developers with Visual Studio - Kaycee Anderson

"Every software developer has the need to debug problems in code, but we are rarely taught how to use the debugging tools available to us. Come to this demo-driven session where we’ll learn how to supercharge our debugging to find bugs faster. We’ll tour most of the debugger, throwing in tips and tricks as we go along, and show a couple new features coming in the next release. Whatever your experience level we guarantee you’ll learn something new." from

Wednesday, 5 October 2016

Continuous delivering continuous delivery - Kim van Wilgen

In her role as CIO at the well-known Dutch insurance company Klaverblad Verzekeringen, Kim van Wilgen is responsible for all software development and operations. Although a nerd at heart, she also has over a decade of experience in product development and comparable managerial roles on the other side: the business. She can still speak just enough of the language of the product owners and the users to understand the gap we quite frequently need to bridge. Kim van Wilgen is passionate about topics such as agile, Kanban, DevOps and continuous delivery. and the management of the cultural, organizational, team and technological changes associated with these approaches. from Build Stuff

Monday, 3 October 2016

How to become Agile without Scrum or Kanban - Kjell Ljøstad

This is NOT a talk about Scrum or Kanban. The Agile Manifesto is all about communication, interaction, collaboration and building trust. Yet when most companies decide to go agile, they focus on implementing some rigid process that they don't yet fully understand, and they have a hard time getting it to work. We go back to the core of the Agile ideology. We will talk about how you can use relational skills to improve communication, get team members engaged and build trust.
Agile initiatives tend to become a matter limited to the developers, and it is often hard to engage other parts of the organisation?. In this workshop you will learn what make teams work efficiently and the basics of how you can get the whole organisation to cooperate better. By building relations and trust between people, working on how they communicate and how they interact with each other, you will build the foundation of a truly agile organization.
Most of us have experiences from both good and bad teams. It is often hard to point out why things turned out the way they did. After this talk you will know what make teams more efficient and increase your awareness of the things that make your team dysfunctional. - Kjell Ljøstad

Sunday, 2 October 2016

Introduction to NoSQL - Martin Fowler

"Martin gives a rapid introduction to NoSQL databases: where they came from, the nature of the data models they use, and the different way you have to think about consistency. From this he outlines what kinds of circumstances you should consider using them, why they will not make relational databases obsolete, and the important consequence of polyglot persistence."

Saturday, 1 October 2016

TypeScript for C# Developers - Chris Klug

Over the last few years, JavaScript has solidified itself as the universal language of the Web. All attempts to change this, like Flash and Silverlight, have failed. So you might as well accept that if you are going to be working with anything related to the internet, it is highly likely that you will be using JavaScript; at least for the foreseeable future. And even if you ignore the browser and stay on the server, projects like Node.js is gaining popularity and putting JavaScript there as well. Unfortunately, JavaScript is not the easiest language to learn and understand. It is full of awesome features and some really bad ones. And being as flexible as it is, tooling has a hard time keeping up. And this is where TypeScript comes in. TypeScript is a superset to JavaScript that tries to solve a lot of these problems, and make the code more structured, and less error prone. And it also offers tooling support in a way that JavaScript just can't. So why not join this session and get an introduction to TypeScript, and see what it can do for you? - Chris Klug