µCon 2016: The Microservices Conference | 7th - 8th Nov 2016

Microservices are all the range, and so are security breaches! Learn what you can do to try and have one without the other.

Microservices give you many options. You can pick different technologies, mix synchronous and asynchronous integration techniques or embrace different deployment patterns. But they also give us different options in how we think about securing our systems. Done right, and microservices can increase the security of your vital data and processes. Done wrong, and you can increase the surface area of attack. This talk will discuss the importance of defence in depth, discussing the many different ways in which you can secure your fine-grained, distributed architectures.

Join this talk is you're a developer, an architect, a technical leader, an operations engineer and if you're interested in the design and architecture of services and components.

You should come away with a working framework for thinking about AppSec, and also understand how microservices can help (or hinder) building a secure system.

About the speaker...

Sam Newman

Sam Newman, a techie interested in cloud, continuous delivery and microservices. Aside from other things he's committed sporadically to open source projects, spoke at more than a few conferences, and wrote some things including the book Building Microservices for O'Reilly.

Find more info on Sam Newman's book "Building microservices" here.

You can find Sam on Twitter at @samnewman.

“It is not necessary to change. Survival is not mandatory.” -W. Edwards Deming

Work takes time to flow through an organization and ultimately be deployed to production where it captures value. It’s critical to reduce time-to-production. Software - for many organizations and industries - is a competitive advantage.

Organizations break their larger software ambitions into smaller, independently deployable, feature -centric batches of work - microservices. In order to reduce the round-trip between stations of work, organizations collapse or consolidate as much of them as possible and automate the rest; developers and operations beget “devops,” cloud-based services and platforms (like Cloud Foundry) automate operations work and break down the need for ITIL tickets and change management boards.

But velocity, for velocity’s sake, is dangerous. Microservices invite architectural complexity that few are prepared to address. In this talk, you'll learn how high performance organizations like Ticketmaster, Alibaba, and Netflix make short work of that complexity with Spring Boot and Spring Cloud.

The Cake Solutions team builds highly distributed and scalable systems using Kafka as their core data pipeline.

Kafka has become the de facto platform for reliable and scalable distribution of high-volumes of data. However, as a developer, it can be challenging to figure out the best architecture and consumption patterns for interacting with Kafka while delivering quality of service such as high availability and delivery guarantees. It can also be difficult to understand the various streaming patterns and messaging topologies available in Kafka.

In this talk, Jaakko will share with you the patterns the team has successfully employed in production and provide the tools and guidelines for other developers to choose the most appropriate fit for given data processing problem. The key points for the presentation are: patterns for building reactive data pipelines, high availability and message delivery guarantees, clustering of application consumers, topic partition topology, offset commit patterns, performance benchmarks, and custom reactive, asynchronous, non-blocking Kafka driver.

About the speaker...

Jaakko Pallari

I work as a software engineer at Cake Solutions Ltd. I have a passion for robust systems, functional programming, and free and open source software. I started my career working as a web developer, and these days I'm responsible for developing backend solutions for global IoT platforms using Scala and the SMACK (Spark, Mesos, Akka, Cassandra, and Kafka) stack.

Jaakko tweets at @lepovirta, and his website can be found here.

From an engineering and operations perspective breaking down systems into microservices is a win - all you have to do is spin up containers.

But what about when the complexity of the business system isn't simple? What about systems where we need to aggregate and combine services to deliver useful business functions that cut across more than one simple service? Event-driven, push-based message passing is often a fundamentally flawed architecture for complex business problems.

In this talk you will discover a resource-oriented view of microservices. Peter will share the trade offs between push and pull architectures. You will explore what lessons the Web's resource oriented architecture offers for complex composite services. Peter will also share how the choice of data format has a profound influence on the composability of microservice solutions.

About the speaker...

Peter Rodgers

Peter Rodgers is the architect of NetKernel and the father of Resource Oriented Computing.

Peter started his research into ROC at Hewlett Packard Labs. When trying to build very large scale software solutions, he discovered that with traditional software he could afford to "build-one" but the long-tail cost of software dwarves the headline costs. He started thinking seriously about the Web as an abstraction for general software with the aim that the economics of the Web could be introduced to any software solution.

Follow Peter at @pjr1060 .

About the speaker...

Greg Young

Greg Young coined the term "CQRS" (Command Query Responsibility Segregation) and it was instantly picked up by the community who have elaborated upon it ever since.

Greg is an independent consultant and serial entrepreneur. He has 10+ years of varied experience in computer science from embedded operating systems to business systems and he brings a pragmatic and often times unusual viewpoint to discussions.

He's a frequent contributor to InfoQ, speaker/trainer at Skills Matter and also a well-known speaker at international conferences. Greg also writes about CQRS, DDD and other hot topics on www.codebetter.com.

There are several practices to run and deploy your application’s micro-services architecture on AWS in a scalable, automatic and safe manner. This presentation will include explanation and examples of how to use AWS micro-services architectures that are highly available, scalable, supply easy deploy mechanism, little configuration and a lot of fun :)

In this presentation, you will focus on 3 examples of AWS services (Elastic Beanstalk, Lambda + API Gateway, and ECS is AWS) that can easily deploy and scale with any micro service architecture, written in any language.

Elastic Beanstalk is an AWS service that can supply services like EC2, ELB and etc. This service configures those features for an application in a way that all the user needs to do is deploy the application using the application templates of supported platforms (Go, Java, .NET, Node.js, PHP, Python, Ruby, Docker). This service does all the work for your application.

ECS is AWS container service that allows deploying your containers and manage them with ease, the service supports Docker so you can deploy any type of application as long as it containerised.

About the speaker...

Josh Dvir

Josh is the managing director of Devopspro. He is an expert in DevOps, Linux, Continuous Integration and Delivery. His expertise also includes Cloud computing, Monitoring, Linux Containers, Version Control, Issue Tracking, Code Review, Development process, Application performance, Analytics, Auto Scaling and Durability.

Josh tweets at @joshdvir.

About the speaker...

Dave Syer

Founder and contributor to Spring Batch, lead of Spring Security OAuth, and an active contributor to Spring Cloud, Spring Boot, Spring Integration, Spring Framework, Spring AMQP, Spring Security. Experienced, delivery-focused architect and development manager. Has designed and built successful enterprise software solutions using Spring, and implemented them in major institutions worldwide.

About the speaker...

Adrian Colyer

Adrian Colyer is Chief Technology Officer (CTO) for the Application Fabric at Pivotal, and was formerly CTO for the vFabric Application Platform and SpringSource at VMware.

Pivotal develops the Spring Framework and associated open source projects such as Spring Integration and Spring Batch, Grails, Groovy, and Eclipse AspectJ.

Cloud Foundry is Pivotal's open platform-as-a-service with full support for Spring, Grails, and a wide range of other application frameworks.

As CTO of SpringSource Adrian led the AspectJ project at Eclipse.org and oversaw the integration of aspect-oriented concepts into the Spring Framework. He helped to grow the SpringSource portfolio from these two projects into the rich set of projects and products that it is today.

Adrian regularly speaks at Skills Matter community events on Spring, including the annual Spring eXchange and at Skills Matter's In-the-Brain Series.

In 2004 Adrian was recognised by MIT Technology Review as one of the top 100 young innovators in the world. He may not be getting any younger, but he is still innovating

As development organizations rush towards microservices and CI/CD, they're finding that their present understanding of their architectures fail to enable agility. A visible architecture is a physical model of a system created by architecture teams using Duplo® bricks, with strings representing data flows. Visible architectures enable teams to collaboratively understand the “as-is” architecture and make better choices on the “to-be” architecture.

The structured, yet creative freedom afforded by the technique enables teams to explore challenging concepts. For example, in one project, teams from Cisco represented known problems as “monsters” and outdated technologies as “dinosaurs” using plastic toys. In another project, teams from Rackspace used Visible Architectures as means to rapidly integrate acquired technologies.

In this talk we'll present an overview of the process, how to document desired changes in a structured manner, and how to augment Visible Architectures with powerful business frameworks that enable architects to "speak the business language" necessary to convert models into realities.

About the speakers...

David Pollak

David Pollak is a long time Scala dude, interested in Functional Programming, Scala, Clojure and making things better.

David has written a popular framework in Scala (Lift) and a book about Scala (Beginning Scala). He's been doing Scala since 2006, and more recently has picked up Clojure.

David has also started work on his Plugh framework and founded Visi.Pro, Cloud Computing for the Rest of Us along with the Visi Language open source project.

Luke Hohmann

Luke Hohmann is the Founder and CEO of Conteneo, Inc. Grounded in the science of play, Conteneo’s enterprise software platforms and professional services merge serious games, data analytics, domain expertise and collaboration to help enterprises optimize decision making in areas of strategy, innovation, sales, product development and market research. Luke is co-founder of Every Voice Engaged Foundation, a 501(c)(3) nonprofit that helps citizens and governments tackle technical and wicked social problems. He’s also written four with long titles and has served on the Board of the Agile Alliance. He's a pretty good grill master and doesn't mind getting lost in foreign cities on long runs.

Or: How to control the risks of continuous deployment for Node.js microservices

The microservice architecture is a powerful way to structure large scale Node.js systems, providing a component model that scales both at the human and system levels. To fully gain the benefits of the microservice architecture, you need to move to a continuous deployment work process. It should be possible for developers to write the code for a new feature in the morning, and deploy it to production in the afternoon. This high-speed development cycle allows you to meet business goals much more effectively.

Continuous deployment brings risks. You can no longer manage those risks in the traditional manner. There is no multi-month release cycle to fall back on. The familiar work categories of development, quality assurance, information security, and operations no longer apply. Instead you must learn to live with the devops approach. But giving developers the keys to the server does not automatically imply less downtime, even if you hand out pagers with the keys, and adopt a "you build it, you run it" philosophy. Even when this approach does work, it is notorious for burning people out. Is there a sustainable set of work practice that reduce the risk of continuous deployment to acceptable levels.

The solution is to take a scientific, engineering based approach, grounded in reality and driven by actual business goals. First, quantify the business objectives, both in terms of the value that you intend to create, and in terms of the cost-benefit of failures. There are always going to be failures, so what's your error budget - how much downtime is acceptable? Second, control the production system by making all changes incremental - you are only ever allowed to add or remove a single microservice instance. Nothing else. Microservice instances are built as immutable artefacts - changes to production are not possible. To change behavior, you must deploy a new instance. This gives you a definitive history of the system. It also gives you a way to measure risk!

Each microservice instance change can be measured. By connecting your quantified business goals to the technical metrics of the live system, you can verify each change. Does it improve the metrics or harm them. If it does harm them, then rollback the change. The rollback is not a major event - it is just the deactive of a single microservice instance. By using immutable microservice instance as the unit of deployment, you enable the use of many risk reduction strategies without needed to build custom implementations. From partial deployment, to canaries, to bifurcated verification, to blue-green deployments, and many others. All of these deployment models are defined as operations on microservice instance activation states. By connecting the state of the system with your business goals, and by operating at speed within a defined error budget, you can fully control the risks of microservice deployment, without need the overhead of traditional release planning.

About the speaker...

Richard Rodger

Richard Rodger is CTO of nearForm, a leading Node.js specialist. He is a technology entrepreneur who has been involved in the Irish Internet industry since its infancy and wrote the seminal book on Node: Beginning Mobile Application Development in the Cloud.

Richard founded the Internet startup Ricebridge.com in 2003. He subsequently joined the Telecommunication Software and Systems Group (TSSG) and became CTO of one of its successful spin-off companies, FeedHenry Ltd.

More recently, he became CTO and founder of nearForm.com. Richard holds degrees in Computer Science (WIT), and Mathematics and Philosophy (Trinity College Dublin). Richard is author of Mobile Application Development in the Cloud by Wiley.

In this talk Stephen Godwin describes how the BBC moved iPlayer to a microservices architecture and how this has allowed new features to be added and large changes to be made without interruption to the service.

In 2012 the system that fed video into iPlayer was a monolith. In the nine months between Jan 2013 and Sept 2013 we replaced it with a new system built on a microservices architecture and running in AWS.

This allowed the BBC to more than double the amount of content available in iPlayer and increase the amount of HD content by 700%.

At the same time it has allowed us to move to a continuous delivery model and our developers can now deploy a component to live in under 15 minutes and perform dozens of live deployments every week.

In 2014 we started serving simulcast content (on-line versions of our TV channels) from this new microservices architecture and during 2015 we added Radio. We now also support Podcasts, Audio and Video Clip Publishing, BBC Store and S4C.

This year we have used the system to serve over 300 hours of live content from the Rio 2016 Olympics and for one event this summer we served over 2 million concurrent users.

About the speaker...

Stephen Godwin

Stephen Godwin is a Senior Technical Architect at the BBC where he is responsible for designing the systems that provide audio and video to BBC iPlayer and iPlayer Radio. He joined the BBC in 2011 and designed the systems that controlled the 24 live streams the BBC made available online for the London 2012 Olympics. Since then he has migrated the systems that power iPlayer to a cloud based microservice architecture.

Stephen tweets at SteveGodwin.

All is not completely rosy in microservice-land. It is often a sign of an architectural approach’s maturity that in addition to the emergence of well established principles and practices, that anti-patterns also begin to be identified and classified. In this talk Daniel will introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project... This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell.

Topics covered include:

Envy - introducing inappropriate intimacy within services by creating a shared domain model, and how many teams deploy and use data stores incorrectly;

Wrath - failing to deal with the inevitable bad things that occur within a distributed system;

Sloth - ignoring the importance of NFRs; and

Lust - embracing the latest and greatest technology without evaluating the impact incurred by these choices.

This is an all-new 2016 version of Daniel's popular 'deadly sins talk' that was recently presented at QCon NY. The talk received 94% highest rating, and was the fifth most attended talk at the conference. Daniel plans to continually improve the presentation based on his learnings and attendee feedback.

About the speaker...

Daniel Bryant

Daniel Bryant is leading change within business and technology with OpenCredo. His current work includes enabling agility within organisations by introducing better requirement gathering and planning techniques, focusing on the relevance of architecture within agile development, and facilitating continuous integration/delivery. Daniel’s current technical expertise focuses on ‘DevOps’ tooling, cloud/container platforms and microservice implementations.

He is also a leader within the London Java Community (LJC), contributes to several open source projects, writes for well-known technical websites such as InfoQ and DZone, and regularly presents at international conferences such as QCon, JavaOne and Devoxx.

My Work

Principal Consultant for OpenCredo

Linked In Profile

Github

Social and Blogging

Twitter

Google+

Blog

Speed and Adaptability; micro services promise so much!

However doing microservices in the real world, productively, as system’s evolve is a massive challenge!

In this talk Russ Miles, Lead Engineer at Atomist.com, and Sylvain Hellegouarch, Engineer at Atomist.com, through story and music (!?) will name and shame those challenges and then show how they can be overcome with the new tools coming into the space.

About the speakers...

Russ Miles

Russ' experience covers almost every facet of software delivery having worked across many different domains including Financial Services, Publishing, Defence, Insurance and Search. With over 18 years experience of consultancy, coaching and training, Russ helps to change all facets of the software delivery process in order to remove unnecessary and costly complexity in everything from developer skills and practices, through applying the right processes for the job at hand, to ensuring that the right change is delivered, be it through software or otherwise.

In recent times Russ has brought the principles of antifragility to software architecture and design, including but not limited to how to implement microservice and reactive software. Passionate about open source software, Russ worked with SpringSource prior to the company's acquisition by VMware, leading the Spring Extensions project and helping international clients to simplify their software by effectively applying the Spring portfolio of projects.

Continuing on from this work, Russ founded the Esper Extension project for applying CEP to Spring Integration messaging and pioneered the Spring Koans open source, test-driven personal learning project.

Russ continues to be involved in the Spring community, regularly speaking on Spring and is the lead of the Spring User Group in London.

Russ is also an international speaker on techniques for helping software adapt to the ever-present force of change as well as a published author, most recently of "Head First Software Development" from O'Reilly Media. He is lead on the London Microservices User Group and heads-up the new µCon conference.

Russ’ current book is being published using the LeanPub platform and is titled “Antifragile Software: Building Adaptable Software with Microservices”. The book will be completed in time for the first initial run of the accompanying course, "Russ Miles' Building Antifragile Software with Microservices”, now available through Skills Matter.

How will you be deploying and managing Microservices in production in the next 1, 2 or 5 years time? More complex systems require more robustness and self-healing. How will we achieve that?

Anne will be talking about the power of orchestration and containers, and how that power will be harnessed to produce Microservice systems that can take the knocks and get back up again.

About the speaker...

Anne Currie

Anne Currie has been an engineer for over 20 years, devising and developing products for cutting edge tech firms. She is the co-founder of Force12.io, an open source project for real time container scaling and reporting.

In this talk you will look at the differences between micro-services and monolith architectures and their relative benefits and disadvantage.

You will explore design patterns which will allow you to utilize these different strategies as a deployment concern without significant changes to the business logic.

You will learn how micro-service architecture can be implemented under low latency constraints of 10 - 100 micro-second latencies, in Java in particular, and how these strategies reduce the impact of serializing data and logging.

About the speaker...

Peter Lawrey

Most answers for Java and JVM on StackOverflow.com (~12K), "Vanilla Java" blog with four million views and ~300 posts, founder of the Performance Java User's Group, a virtual JUG with ~2K members, architect of Chronicle Software, open source project for high performance, low latency libraries in Java, & Java Champion

Peter tweets at @PeterLawrey, and his blog can be found here.

It can be tough to test an apparently simple service comprehensively. A microservice architecture brings a new level of complexity to the question “How can we validate that our API is working as intended?”

In this talk Michael will explain how to use test driven development for APIs and even further how TDD can drive an API Design towards a more usable design, and how to build an well-tested ecosystem of microservices. This approach is applicable for different kinds of services (REST APIs, websockets, industrial protocols). Independent from the type of interface we always ran into similar problems when we build an ecosystem of services. We have to deal with dependency, asynchronous behaviours, fallback mechanisms, endpoint versioning and sometimes even shared databases. It's not trivial to apply TDD to these kinds of problems cause you have to think of scenarios. But there are ways of identify these scenarios and to test them.

As an API specialist Michael worked with various clients designing, building, testing, maintaining and even redesigning private and public services. Based on his project experience he developed a practical approach to apply TDD to APIs in microservice ecosystems.

About the speaker...

Michael Kuehne

Michael worked as an independent API specialist for many years. He advised his clients in terms of API design, authorization standards, development processes and the implementation itself.

Nowdays as head of development at Cybus he leads the development of the cybus middleware, a industrial internet of things solution which bases on a microservice architecture.

Follow Michael at @michikuehne.

You will learn about using language agnostic micro services approach to handle data and provide interactive analytics in a Deep Learning / AI startup.

You will explore use cases and an example of a distributed queue based architecture for micro services.

Andrew and John will be demonstrating two different 'frameworks' for microservices in a Big Data architecture (with examples):

1. Kafka Consumers as microservices - image processing

2. Spark Jobs as microservices - clustering algorithms + data visualisation

Andrew and John will also share their experiences of using microservices at Tractable.

About the speakers...

Andrew Jefferson

Andrew is a software engineer specialising in realtime data systems. Andrew has worked at YC Startups and at Apple on applications ranging from Ticketing to Genetics. Currently building data systems for training and exploiting Deep Neural Networks for Computer Vision.

John Bradshaw

John is studying for a PhD at the University of Cambridge and the Max Planck Institute for Intelligent Systems, Tübingen in Machine Learning. Prior to that he worked as an engineer at Tractable implementing scalable Machine Learning algorithms.

Autonomy and isolation are some of the core values of microservices, allowing for independent changes and independent deployments. As loosely coupled services interact on interfaces managed under different lifecycles and even different teams, making sure that a simple change did not break the application can turn into an integration nightmare.

Consumer-Driven Contracts testing brings an alternative integration testing approach for distributed systems, relying less on live-like integration environments and more on making interactions explicit and quickly verifiable.

This talk will cover how Newsweaver has made CDCs part of its pipeline with Pact and how it improved collaboration and confidence between teams when designing APIs.

Software security is hard. Software security in Microservice Systems is even harder. Microservice-style software architectures have steadily been gaining popularity in recent years. They offer many benefits over traditional monolithic software products, however they also introduce new challenges - one of these being security.

In recent years David has worked on this problem in several independent projects, and this talk will draw on his learnings within the topic of authenticating end-users. David will describe, compare and evaluate several authentication options from the perspective of how secure they are and how well they comply with the qualities of a well-designed microservice system. You will leave the talk with suggested evaluation criteria and guidance for implementation based on their use cases.

About the speaker...

David Borsos

David is a software developer with ~8 years of experience working with Java applications, with OpenCredo since 2013. In the past few years he's worked on microservice-style systems delivered for various clients; using open-source technologies.

Deploying a new version of any app can be a tricky thing to do. Yet, we often make it even harder on ourselves, by keeping manual actions in the process; deploying big releases instead of small iterative chunks or even keeping new features in branches for a long time before moving everything to production.

In this talk, Damien will talk about how him and his team are applying several various patterns to improve deployments of the Heroku platform, and how you can apply them to your own app so you feel confident if deploying a change on a friday.

About the speakers...

Kingsley Davies

Kingsley is a Director at D-limitd, and has spent over a decade designing, developing and supporting large scale systems for a number of clients including, Betfair, the BBC, Barclaycard and others that don't start with a B ;-) While working to make things better, he’s seen a steady evolution towards functional programming, a sharper focus on development operation teams and tools and decomposing big things into smaller composable things commonly called services.

Gary O'Connor

CTO at Doddle.

Over a decade in senior technology roles at IBM, Betfair and the BBC.

Focus on building event driven, microservice architectures in cloud environments .

Experience of building and operating microservices from Enterprise environments to startups .

Currently scaling a microservice based SAAS platform for a pioneering UK based Click and Collect business.

Gary tweets at @garyoconnor99.

Robert Shield

Robert Shield is a Principal Software Engineer at the BBC where he has been for 6 years, working previously on Video Factory and live audio and video streaming. He is currently leading a team of engineers developing a micro-service orientated architecture implementation of file based delivery, ensuring BBC programmes are fit for broadcast and delivered to playout on time.

Simon Hildrew

Simon Hildrew is currently a Lead Software Developer at the Guardian where he has done everything from running the operations team, overseeing the migration of several products to AWS to building the Guardian's continuous delivery platform. His interests are in functional programming, DevOps and most recently serverless architectures.

Have a look at some of Simon's working projects. Simon tweets at @sihil.

About the speaker...

Andy Czerwinski

One of a team of Architects that shape and drive the Digital Transformation of the British Gas website. Advocate of HTML5 and the move to client side applications running in client Browsers. Advocate of API technology and API's to split the views (supplied by EmberJS web applications) and the data via microservices (supplied by RESTFUL api's using NetflixOSS and SpringCloud/SpringBoot).

Andy tweets at@czeggers.

The monolith applications world got you used to services connected to each other in direct, easy ways. The cloud environments and the modern and current microservices architectures with virtual or containerized setups where the instances can vary in number and location, create an ever-changing context where the communication between services becomes a bit more complicated.

Alex will explore some of the different patterns of Service Discovery in a microservices architecture, and focus on pros and cons, while also mentioning concrete examples of tools and software available.

About the speaker...

Alex Ramírez

A true lover (and geek) of all online areas and the Internet, I have many years of experience in software architecture and development of high availability, high traffic and algorithmically complex environments and applications. I live in the Internet since 1994, and have worked professionally in most online areas since 1996.

Alex tweets at @alexramirez, and his website can be found here.

Building Microservices is, at heart, about building Distributed Systems.

Much research and effort has gone into orchestrating distributed components, but how should they actually communicate to give the properties that you want, AP, resilience, antifragility, self healing, graceful degradation?

This is the realm of communication protocols, and this talk introduces the core concepts you need, and shows how to use various protocols and implement new ones using a new Microservices Toolkit from Simplicity Itself and Sky CIS Tech Futures: Muon.

Covering async vs sync, event based systems, transactional behaviour over distribution and far more, this is a dive deep into how modern Microservice systems should be built, and how you can get there.

About the speaker...

David A. Dawson

David Dawson is CEO of GoMicro.Services, takes his passion for design, architecture and philosophy to all their clients, drinks their coffee and gives them Microservice platforms and systems in return.

Alongside running GoMicroservices, David advises the other Simplicity Itself companies, GoDataScience and GoCloudNative, dreaming, designing and building an event oriented cloud based artificially intelligent world. This is closer than you think.

He lives in the north of England, next to the Pennine national park, and can be found hiking the hills.

About the speaker...

Brendan McAdams

Brendan is a Senior Consultant & Trainer at BoldRadius, where he works directly with clients to help them find success through consulting and training on the Typesafe Reactive Platform.

With over 15 years of software development experience, Brendan boasts an impressive resume that has seen him work at Netflix, Typesafe, and MongoDB. Brendan is a renowned speaker and luminary in the Scala community, and is a regular presenter at industry leading conferences such as Scala Days and Scala eXchange. His deep technical knowledge coupled with his outgoing and approachable personality not only make him a great speaker, but also a phenomenal trainer on the Typesafe Reactive Platform.

Check out BoldRadius here, or follow Brendan on Twitter.

Microservices are great to split the functionality of an application across multiple processes, containers or vms. At their core however, there are still the age-old concepts of rpc, publish-subscribe and work queue, with the central state of our application is stored in a database. With that, you need to answer the same age-old questions,

*How can you support a constantly changing state?

*How can you move streams of data across our microservice network?

*How can you split system state across multiple processes, containers or vm?

Enter Upring. Upring is a library to support application-level sharding of “live” data, it supports node streams, and enables every developer to implement application level sharding. What can you shard? As an example, Upring allows to connect two user with a bidirectional communication (the beloved websocket) across hundreds of machines.

At its core, it is a state discovery system.

About the speaker...

Matteo Collina

Matteo is a code pirate and mad scientist. He spends most of his days programming in node.js, but in the past he worked with Ruby, Java and Objective-C.

He recently got a Ph.D. with a thesis titled "Application Platforms for the Internet of Things". Now he is a Software Architect at nearForm, where he consults for the top brands in world. Matteo is also the author of the Node.js MQTT Broker, Mosca and of the LevelGraph database. Matteo spoke at several international conferences: NodeSummit, Nodeconf.eu, LXJS, Distill by Engine Yard, and JsDay to name a few. He is also co-author of the book "Javascript: Best Practices" edited by FAG, Milan. In the summer he loves sailing the Sirocco.

Follow Matteo at @matteocollina.

With microservices simple things become complicated, from local development environment to testing to inter-service communication. Authentication is no different, especially if you don't only think about how to authenticate the user over the distributed environment, but also about how to authenticate and authorize a service when it talks to an other one.

In his presentation Daniel will share the history of authentication and authorization at Prezi and talk about what process and design decisions lead us to our current approach, especially to inter-service authentication.

About the speaker...

Daniel Torok

I'm Daniel Torok, I'm a senior backend developer with some sysadmin background. I like to work in a team, coding, testing, getting projects done. At the same time I also like to think about big, challenging problems, analyzing them, taking them apart and figuring out not just the long term solution, but also the path that takes us to that direction with giving value all over the way, from the very first step.

I've been working at Prezi for more than 4 years, during those years we changed our architecture from one django application running on physical machines to bunch of small services running on virtual machines at AWS. We faced all the typical microservices-related problem and figured out the solutions that matched our needs the best. Obviously we are far from finished, as the company and the architecture grows more and more problems come to the surface, part of my job is to have a proper plan to minimize the risk and eliminate the pain of those problems.

In my spare time I either work or play the piano, but I also try to spend with my family as much time as I can.

I tweet at @danisoft.

In many talks over the years Russel has been presenting "dataflow" and to a lesser extent "actors" as architectures for systems. At last year's μCon Russel gave a presentation on this sort of thing. His proposal for this year is for a continuation of some of the ideas in that talk. Not a rehash, definitely an extension and expansion of the ideas. In particular it is clear that microservices instances are effectively actors, but can it be "actors all the way down". Clearly not because at some point we have to work with real hardware which is very, very rarely an actor system.

Microservices can be implemented in many languages Go, Python, D, Kotlin, Ceylon, C++, Java,… does the choice of programming language have a critical effect on the achitectures of microservices.

The session is about scaling of architectures and at what point there have to be "fault lines" to other architectures and whether this turns out to be seamless or the location of real problems..

About the speaker...

Russel Winder

Russel Winder is an independent consultant, analyst, author, expert witness, and trainer at Skills Matter and an expert on Java, Groovy, Scala, Python, D, Go. Gradle, SCons, Waf, SBT. Bazaar, Mercurial, Git.

Russel tweets at @russel_winder.

So you’ve embraced μServices and Continuous Delivery but as the number of your μServices grow, it has become harder and harder to keep your releases co-ordinated. Many resort to release trains to manage their deployments, where you can only do releases for a given service at a given time or in a specified order, but wouldn’t you like to not have to worry about any of that coordination, no matter how many μServices you need to deploy. Over at Ocado, they have managed to create an environment where they are able to release up to 35+ μServices at any time and in any order you want, asynchronously. Clayton and the Ocado team would like to share with you how we are doing it.

In order to create such an environment, you will need to look at more than just one thing or one area of practice you are doing. You need to take into account almost everything related to your environment and development life cycle. In order to achieve this goal, you will explore the following areas:

• Stateless μService Architecture

• Fallback strategies

• Resiliency

• Continuous delivery practices

• Development approach and practices

Adopting this approach has allowed the Ocado E-commerce team to actively allow 20+ developers each able to continuously push changes all the way through to production in under 40min from the moment the change is committed, without needing to worry about the changes other developers are pushing through and no need to worry about each developer having to coordinate their releases and work with each other.

About the speaker...

Clayton Wells

Currently a Software Engineering Team Lead at Ocado Technology where we are responsible for the delivery of the E-commerce solution to the Ocado Smart Platform in an Agile manner. I've been with Ocado for 3 years now.

I have been working in Software development for the last 11 years where I have focused on the redesign and rebuilding of systems in an SOA approach which has naturally progressed to using micro-services and Continuous Delivery.

I have strong interests in agile methodologies, continuous delivery and SOA systems design.

Clayton tweets at @ClaytonAMWells.

Knowing what's happening in your system is key to effective monitoring, troubleshooting, and crisis resolution. Unfortunately, when your microservice ecosystem scales to dozens or hundreds of microservices and every user action involves 10 microservices to complete, it becomes incredibly difficult to have that needed visibility and insight. At Jet, they want to know the current state of every distributed process, numbering a few hundred million per day. To gain this visibility the team coupled a common communication protocol which provides an ID to correlate all the messages in a single process with telemetry collection for every act of communication between microservices; pulling this data together results in a stream of data from which the current state of our 100 million daily processes can be viewed with ease.

This stream of data allows the Jet team to effectively build metaprograms which operate on the state of the distributed system. For example: monitoring for end-to-end SLAs, checking the status of any single process, powering your Ops platform, and automated integration testing of an entire distributed system.

This talk will share with you what the Jet team has done to build this real time, holistic view of our 700+ microservice architecture, so that they can monitor every single process for completion, validate that every single process is behaving as expected, empower their operations team to investigate and triage long running processes (e.g. catalog management and clean up). The talk will cover the DrOrpheus communication protocol they use to create their distributed process context, the telemetry data collection architecture, and the XRay real time telemetry processing platform which enables them to convert billions of telemetry events per day into many different, but accurate, views of their distributed systems state.

About the speaker...

Erich Ess

Directory of engineering at Jet.com. Building distributed systems and microservice platforms.

Previously, I've been a CTO for a small start up, engineered distributed systems, and did research into scientific visualization.

Erich tweets at @egerhardess , and his blog can be found here.