March 8-10, 2017
Montreal, Canada
Architecture & design patterns Conference 2017
Architecture & design patterns
What if there was a full-stack framework in Ruby that was focused on being lightweight, structurally pure and fun to use? There is! Say hello to Hanami. Hanami is a modern, full-stack, web framework for Ruby. You'll have an opportunity to see a different approach to approach MVC (Model, View, Controller) in Ruby. We'll be building a web application from scratch using the tools Hanami gives us.
Architecture & design patterns
Async I/O is fashionable with good reason: its low per-connection overhead lets you scale an I/O-intensive workflow better than threads or processes. But there are drawbacks. I'll explain the pros and cons, show how they bit in a real-world project, and help you to weigh the options for your next project.
Architecture & design patterns
Microservices invite architectural complexity that few are prepared to address. In this talk, we’ll look at how high performance organizations like Ticketmaster, Alibaba, and Netflix make short work of that complexity with Spring Boot and Spring Cloud.
We'll look at the patterns required to build distributed systems including centralized configuration, client-side loadbalancing, circuit breakers, distributed tracing, single signon, and more.
We'll look at the patterns required to build distributed systems including centralized configuration, client-side loadbalancing, circuit breakers, distributed tracing, single signon, and more.
Architecture & design patterns
Passwords are bad. We all know it, but we also know you're not going to build a service that doesn't use them - not if you like paying the rent. However, we can do a lot better. We'll take a whirlwind tour through the aspects of connecting people to your service, from generating passwords, not using passwords at all, creating users with one tap, identity providers, automatic cross-device sign-in, and password managers. Sign-in should be simple.
Architecture & design patterns
Amazon Lambda is shaking-up Java server-side development. Now you can write services in the cloud without having to think about app servers or containers. This is revolutionary. This session will cover Amazon Lambda and some of the other services that will reduce the about of code and infrastructure you have to write and maintain.
Architecture & design patterns
Reactive applications are designed to handle asynchronous events in a way that maximizes responsiveness, resiliency, and elasticity. Reactive Extensions (Rx) is a library that abstracts away the sources of events and provides tools to handle them in a reactive way.
With Rx, filtering events, composing event sources, transforming events, and dealing with errors all become much simpler than with traditional tools and paradigms.
With Rx, filtering events, composing event sources, transforming events, and dealing with errors all become much simpler than with traditional tools and paradigms.
Architecture & design patterns
Come learn how to better communicate between Python services. We'll use simple-to-follow examples and go from a service with undocumented endpoints to one which has full docs and validation on requests. Learn how to use Swagger tooling for python, including the bravado (client) and pyramid_swagger (server) libraries. In the end, you'll (hopefully!) find nirvana and make the machines do all the hard work for you.
Architecture & design patterns
CSS floats have been the primary way that we define web layout for almost the past decade. They’ve worked pretty well over the years but times are changing. flexbox is becoming the new norm for layout and solves some of the main gripes we deal with when using floats. Some of the new concepts may be a bit difficult to grasp in the beginning but in this talk we’ll focus on practical ways that flexbox is used when creating modern interfaces.
Architecture & design patterns
Separated layers are one of the fundamental principles of software design. Your framework is the topmost layer, and your business code should not depend on it. While we will touch a few package design basics, the focus is on how to actually *DO* it: Expose the user accounts in your model to your framework without depending on it. Separate form input validation from entities. Isolate ORM-specific code in bridges. And be pragmatic about it.
Architecture & design patterns
We browse the Internet. We host our applications on a server or a cloud that is hooked up with a nice domain name. That’s all there is to know about DNS, right? This talk is a refresher about how DNS works. How we can use it and how it can affect availability of our applications. ow we can use it as a means of configuring our application components. How we can use it for things that it wasn’t built for. Come join me on this journey through DNS!
Architecture & design patterns
Applying principles from Domain-Driven Design such as strategic design and bounded contexts, this presentation will help you choose and apply the right data layer for your application's model or models. We will explore traditional relational databases, graph databases, document databases, key/value stores, polyglot persistence, CQRS, event sourcing, and data layers for microservices.
Architecture & design patterns
Event Sourcing can look like an attractive solution for any of your applications, but does it actually pay off?
What if it is all just buzzwords and no gain?
We’ll look at how we implemented event sourcing in our own app, code-reviews.io: what made us fast, what made us super slow, what made us cry.
This talk will give you a good idea of what kind of challenges you will encounter when approaching event sourcing for the first time.
What if it is all just buzzwords and no gain?
We’ll look at how we implemented event sourcing in our own app, code-reviews.io: what made us fast, what made us super slow, what made us cry.
This talk will give you a good idea of what kind of challenges you will encounter when approaching event sourcing for the first time.
Architecture & design patterns
Resistant, highly testable, safe and maintainable code: or not?
There are a thousand ways to break your code, and a lot of ways to prevent that from happening.
Let's explore defensive programming and learn how to protect our code from invalid usage.
There are a thousand ways to break your code, and a lot of ways to prevent that from happening.
Let's explore defensive programming and learn how to protect our code from invalid usage.
Architecture & design patterns
Ruby is the epitome of an object-oriented language, with everything from integers to nil being represented as objects. Still, there is room for object-oriented Ruby designs to benefit from functional programming concepts. We'll go over how the functional programming idea of small, isolated units without side effects applies to the design of objects as well as functions, and how this approach leads to highly maintainable and testable code.
Architecture & design patterns
I love programming in Ruby, but I've mostly used it like a more elegant Java - solving business problems in a straightforward way. I always knew Ruby had lots of metaprogramming power, but I was too busy getting work done to explore it. I recently worked on a project which let me use more of the magic of Ruby.
This talk will show how I made it to the next step in my Ruby programming, turning ugly code into refined haiku.
This talk will show how I made it to the next step in my Ruby programming, turning ugly code into refined haiku.
Architecture & design patterns
Web APIs are relatively simple to implement, which has led to many ill-conceived APIs out in the world. Creating APIs that make developers jump for joy is a goal we should all have, and this proposal outlines a process for API development which will result in a better considered product.
Architecture & design patterns
A long time ago J2EE and especially application servers were considered to be too bloated and "heavyweight". It could be quite tedious and discouraging for developers to use that technology for developing applications. But since the name change to Java EE that assumption is not true anymore.
This session shows the benefits of developing against a well-established standard and why Java EE is one of the most lightweight and productive solutions.
This session shows the benefits of developing against a well-established standard and why Java EE is one of the most lightweight and productive solutions.
Architecture & design patterns
Programmers can find domain specific languages everywhere from XML to SQL. What if we could read and write DSLs in a completely type safe manner? One way to do this is implement your own custom developer tools. But there is a second way! You can write a type-safe API in a statically typed language like Java, giving IDE-agnostic completion and static analysis. We'll explore how to generate your own custom DSL interpreter in Kotlin.
Architecture & design patterns
Let's examine the ups & downs of adopting a microservices architecture and why, in most cases, the pros outweigh the cons. The presenter will discuss & demonstrate how to build & integrate microservices using popular open source tools. Risks & mitigation strategies will be discussed & shown, including load balancers, circuit breakers, tests, & other mechanisms at your disposal to increase software quality.
Architecture & design patterns
As an application starts to grow, the flexibility that inclined us to build a monolith vanishes. The once reliable system is now prone to errors, bugs leak to unexpected places and new features take a considerable time to be delivered. Spotify, Amazon and Netflix solved these problems moving to microservices, giving back productivity and confidence to developers and stakeholders. I want to share some guidelines that helped me do this transition.
Architecture & design patterns
A travers cette conférence, je me propose de vous tracer l’histoire de la migration de 6play (système de télévision de rattrapage du groupe M6, premier groupe de télévision privé français) d’une application monolithique vers un univers de micro-service, des avantages en terme de maintenance, d’évolution, de montée en charge, mais également des différents écueils rencontrés lors de ce changement de paradigme : caching, logging, complexité globale.
Architecture & design patterns
Failures are the bane of scaling a modern web service and can cause serious pain for your end users! Lucky for us, there are techniques that can help protect your product handle failures in subsystems gracefully. This talk will dive into one of these in depth, the Circuit Breaker pattern, and explore the options it gives us for keeping all our users safe.
Architecture & design patterns
Everybody is doing REST -- at least everybody claims they are. But mostly web APIs are built without Hypermedia, what would allow the client to follow related resources and autonomously navigate through the API without prior implicit logic of the application.
This sessions shows the concept and benefits of a Hypermedia driven REST API and how to implement this using JavaEE 7 with JAX-RS.
This sessions shows the concept and benefits of a Hypermedia driven REST API and how to implement this using JavaEE 7 with JAX-RS.
Architecture & design patterns
Grafana allows us to monitor and to query the metrics of our applications in a rich, beautiful dashboard. I would like to share the use case of a Brazilian insurance company where it is saving us money and increasing the speed with which we detect (and fix) problems.
Architecture & design patterns
Dans cette présentation nous verrons une brève introduction aux design patterns, leur origine et pourquoi nous devrions les apprendre après quoi nous passerons le reste du temps à transformer un exemple de code en appliquant certains des « patterns » les plus communs comme : factory, decorator, composite, command, …
Architecture & design patterns
Design patterns are conceptual solutions to solve common redundant problems in software engineering. However, learning them is not easy as litterature or tutorials on the Internet often introduce them with theorical examples. This talk gives you a slightly different approach by introducing some of the most useful design patterns with practical code samples to solve real world problems.
Architecture & design patterns
Spring Boot has taken the world by storm. In this talk we'll look at how to build production-worthy services and applications quickly and easily with Spring Boot, building upon the best-of-breed components from all across the Java ecosystem.
Architecture & design patterns
There are seven fights that I have over and over again, whenever I start at a company. I'm here to convince you that it's valuable for everyone to have these things in mind from the inception of a project.
Having these fights early prevents you from doing the software equivalent of poking chocolate chips into an already-baked cookie. They are: localization, security, extensibility, documentation, affordance, acceptance, accessibility.
Having these fights early prevents you from doing the software equivalent of poking chocolate chips into an already-baked cookie. They are: localization, security, extensibility, documentation, affordance, acceptance, accessibility.
Architecture & design patterns
Write once read many. Stop rediscovering what you already figured out. In this presentation we will see five effective low-cost refactoring practices that will help improve the clarity of your code. You should take time once to make your code easier to read so no one else will have to spend that time again. In this session you will gain valuable tips to help you accomplish just that.
Montreal 2017
sponsored by
© 2010-2024 ConFoo. All rights reserved. Code of Conduct
Managing Cookie Consent
To provide the best experiences, the usage of cookies are necessary. Some are essential for the proper functioning of the site, while others help us better cater to your interests.