Russ Miles will explore why the Architectural Monolith’s days are numbered. Looking at the greatest failures and small successes of the past, He will help us understand the properties we need from our software in order to survive in a post-agile future and where antifragility, reactive and microservices architectures fit in.

In the future your software won’t just have to embrace change, it will need to thrive on it. In this talk you’ll find out how that is achievable today.

In this talk, James Lewis will examine the characteristics of the microservice style using examples from projects over the last few years. Topics covered include the reasons you might want to split an application (or not), the benefits and the drawbacks of the style based on these experiences. Remember though, Rule 16. Distrust all claims for "one true way.”

Business models are undergoing unprecedented disruption as the full force of the digital revolution is being felt. Nimble competitors are innovating fast and bringing incumbent market leaders to their knees. A core strategy in fighting disruption is the management and implementation of the innovation process: generating, selecting, and propagating new ideas around an organisation. So what can we do to improve this process?

This talk explores the innovation process, and how an Innovation Platform, based on microservices, can help you accelerate success by reducing the burden of experimentation. An Innovation Platform brings the promise of nitro to your development teams giving them a competitive edge when considering new ideas.

The basis of such a platform is a micro-services architecture with PaaS like features that provides low barriers to entry and reduced friction to ’try’, allowing new ideas, no matter how small, to be easily packaged as a production worthy, and provable, service.

The goal of this presentation is to give you the knowledge, jedi mind tricks, process, and tools to find a way to innovate and experiment almost limitlessly using microservices while happily mitigating the typical risks of such diversity.

They do not age well; are difficult to change; difficult to understand; difficult to test; difficult to diagnose issues; and quickly become saddled with overwhelming technical debt. Is there a better way? Microservices based architectures look very promising. But what exactly are microservices? How do you get started? What are the benefits? What are the trade-offs? How do you design them? I will share with you my journey to the discovery of micro services. The goal of the talk is to help you understand if a microservices based architecture might be a good fit for the business problem you are trying to solve.

We needed to be an agile organization, that can quickly iterate on ideas, deliver what its users really want, and critically, move faster than the competition. In this talk I’ll explain how micro-services, metrics, and small cross-functional teams enabled us to be such an organization.

You've bought into the dream of decentralisation and signed up for services and monitoring in place of objects and unit tests. Your team members are itching to write tiny applications in multiple languages and to deploy independent components many times a day. But before you can enter the brave new world of microservices, you'll likely need to convince someone in a suit that it's worth giving you time and money to try out this unfamiliar development method. CEOs, CTOs, CFOs, and others in the boardroom brigade are skeptical and risk-averse by nature. What problems might they see microservices solving for them, and are these sufficiently important issues to warrant substantial investment?

In this session, we'll look at the history of methodology innovations and reflect on why some fail (formal verification, tuplespaces) and others succeed (agile development, object-oriented programming). We'll remind ourselves about Moore's technology adoption lifecycle (innovators, early adopters, early and late majority). This will give us context for statements like these from real executives (sound familiar?):

• "Doing twice as much on the same budget is a good challenge for them."
• "Every developer wants to rewrite the code base from scratch."
• "All I ask for is faster development and the next thing I know they're all pairing or deploying or whatever."

I'll put the case that certain promised benefits of microservices should be music to the ears of the C-suite - but not necessarily for the same reasons they delight us techies. These include:

• easy, habitual rewriting - to eliminate development drag from long-term technical debt
• independent component deployment - to keep features flowing to key groups
• monitoring business metrics - as a check on the possibly unintended consequences of rapid change
• decoupled services with simple connectors - to help ease reallocation of people and resources

And I will argue that some elements of microservices may give execs the heebie-jeebies, and that if they are of sufficient concern, may indicate that microservices aren't suitable for the circumstances. For instance:

• a group of fast-evolving, independent components are likely to exhibit a certain amount of emergent behaviour, and if uncontrolled in a system with real-time effects, this can pose a huge risk (see Knight Capital 2012)
• building a multilingual team can be difficult and expensive, and maintaining the polyglot system they create may be impossible for traditionally-structured firms
• organisational barriers may make some practises impossible to adopt, or just politically difficult to consider - e.g. company policies on database administration or entrenched, separate QA or operations teams We will discuss these and other potential objections, as well as possible mitigations.

I hope attendees will find it helpful to have had this tour of microservices from the executive's point of view - both for making a case for the method in their organisations, and for carefully considering whether it is suitable for them.

Learn more about Spring Boot, Spring Cloud and check out Spring Cloud Sample Code.

Avoid the Monolithic mistakes of the past by learning how to use Node.js and microservices in unison and keep code volumes low, easily throw away problematic code, apply effort where it most needed, and go home early!

We will look at these lessons from both a theoretic and practical perspective using several real-world case studies involving a move from monolithic applications deployed into a data center on a 'big bang' schedule, to a platform of JVM-based loosely-coupled components, all being continuously deployed into the Cloud. Topics discussed will include API contracts and documentation, architecture, build and deployment pipelines, Cloud fabric properties, monitoring in a distributed environment, and fault-tolerant design patterns.

From the “Distributed Monolith” to the ""Enteprise-OSGI-Application-Service-Bus”, this talk will take a tour of some of the nastiest anti-patterns in micro services, giving you the tools to not only avoid but slay these demons before they tie up your project in their own special brand of hell.

Take a walk through an example of a large real-world legacy financial services platform that’s under improvement. Understand the challenges this presents, where existing tools and techniques fall down, and why micro-services might be a better way.

Join Udi for a discussion of a unified approach that leverages the best of both worlds.

What are the qualities of microservices, how can we determine the right size for a service, what are the consequences of our service integration patterns, what's the difference between the logical and physical views of a service and how can avoid avoid the traps of yet another failed SOA?

Looking back with the benefit of hindsight, we review the reasons for our decisions, the mistakes we made and the lessons we learnt about implementing and deploying microservices.

Topics We Hope To Cover - Reasons for using microservices - Service decomposition - Microservice isolation in the cloud - Implementing security - Deployment without insanity - Introducing microservices to a different team - Operating and maintaining the architecture"

Aggregating reponses used to involve only a single database join; now information is retrieved from multiple services by making several API calls, introducing complexity and latency. Caching becomes much more important to ensure our new aggregation-based service can deliver results in a performant, responsive manner. But where should we create this cache? How long should we cache for? Should our services be aware of it? What software and architecture should we use when creating our caching platform?. We will talk about our approach, and our use of NGINX, Memcached and Couchbase to boost the performance of our services.

This presentation will describe a set of architectural patterns for building out resilient, consistent microservice-based systems that leverage off-the-shelf products that are already inside your organization. We will discuss the implications of those patterns in terms of the system's overall operation, what tooling you need to build out to effectively manage your platform, and the functionality that you need to build to support those tools. You will come out with a much clearer picture of the main considerations, as well as a list of tasks, that need to be addressed to build and operate a platform based on microservices.

Bert is the co-author of the O’Reilly book 'Building Modular Cloud Apps with OSGi' and is using these tools and techniques in high profile production applications on a daily basis. There are interesting parallels to draw between this approach and with what is being called muServices today.

We'll demonstrate how to take any off the shelf Java project using maven with any framework, libraries or middleware and immediately deploy it as a microservice; either stand alone, on docker, on EC2 or on a PaaS like OpenShift with manual or automatic scaling while taking care of all the management, service discovery, load balancing and wiring while having full operational monitoring and management tooling.

We'll demonstrate

• how to perform rolling upgrades of changes across micro service versions
• how to understand and use the available APIs within your environment
• how to automatically collect logs and metrics
• how to provide sophisticated automatic load balancing across services including version migration for accessing services from any language or runtime
• nice web based tooling so folks can understand their whole system easily.
• how to migrate iteratively from an application server centric approach to micros services as you gain more confidence in using finer grained deployment units and moving away from application servers to smaller, more focussed micro services.

All using 100% Apache Licensed open source tools. We hope by the end of the talk you’ll be eager and ready to try deploy your first micro services in your environment.

Don't come to this talk if you'd like any more of that.

I'm going to talk about distributed computing, why it matters and why you need to care when developing your systems. The conventions that are developing around Microservices create certain effects in your newly minted distributed system.

Come to hear about some of them, what you should harness, what you should fear, and where this has led us to push technology.