December 5-7, 2016
Vancouver, Canada
Architecture & design patterns Conference
Architecture & design patterns
When it comes to designing and writing software, we should make handling change one of our main concerns. Nearly all of us do it, even if we don't usually call it that. In this talk we'll discuss the principles of Change Driven Design. We'll also explore some software architecture methodologies that position handling change as a core concept and design principle.
Architecture & design patterns
There are many considerations you should take into account when designing the database architecture of a Software-as-a-Service (SaaS) product. Scalability, geography, security, ease of implementation and deployment, performance, and data retention are all factors to consider. We’ll explore these issues, look at single and multi-tenant database models, and discuss options in both relational SQL and non-relational noSQL worlds.
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
Devices already consume most services/data, but they have to get those services somewhere! Learn how to use proven patterns and open source software to quickly and effectively build edge services that marshal and streamline communication between your key services and end-users with devices in hand. The presenter will demonstrate how to develop & manage microservices using OSS tools employed by Netflix to keep movies streaming globally 24/7.
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 demonstrate how to build & integrate microservices using popular open source tools. We’ll discuss and learn risks & mitigation strategies, including load balancers, circuit breakers, tests, & other mechanisms at your disposal to increase software quality.
Architecture & design patterns
Music and code. Two things that outwardly seem very different. And yet, whether performer or programmer, you have a number of the exact same considerations. This talk will demonstrate how approaching both roles with the same mindset can improve your performance in both.
Architecture & design patterns
There are myriad data storage systems available for every use case imaginable, but letting application teams choose storage engines independently can lead to duplicated efforts and wheel reinvention. This talk will explore how to build a reusable data pipeline based on Kafka to support multiple applications, datasets, and use cases including archival, warehousing and analytics, stream and batch processing, and low-latency "hot" storage.
Architecture & design patterns
No one ever wants to write another REST API client. AutoRest (https://github.com/Azure/autorest) + OpenAPI (https://openapis.org) specifications (Swagger) can make this a reality. Join me as we talk about API specifications, REST API patterns, and how you can combine the two to create an opinionated code generator to create beautiful REST API clients. We'll generate code for C#, Java, JavaScript, Ruby, Python and Golang.
Architecture & design patterns
Inspecting your data and telemetry in real time before storage in a latent data analysis solution like Hadoop gives your data pipeline opportunities to leverage insights that can be used in immediate decision making.
In this talk, we will discuss the power of real time data analysis when used in combination with latent data processing, discuss development with Apache Storm, and examine operational considerations in production deployments.
In this talk, we will discuss the power of real time data analysis when used in combination with latent data processing, discuss development with Apache Storm, and examine operational considerations in production deployments.
Architecture & design patterns
The talk will cover exactly what the state pattern is and how it's used in a game. Then we'll be discovering what this can do for us in the world of web applications. Following that we'll take a brief look at the state machine to see how it's different from the pattern and why it's useful to us. We’ll put theory into practice throughout the talk by continuously showing examples. And we’ll even include some live coding.
Architecture & design patterns
Have you heard about type theory and always wanted to understand the principles behind it, but always thought it was too complicated since it has a lot of Lambda Calculus and algebra? Type Theory is a concept that is sometimes regarded as boring or too difficult, and this talk will show that any developer can understand those principles and maybe apply them to improve their decisions on architecture.
Architecture & design patterns
Elm, Figwheel, Redux, and other environments that carefully manage state have popularized reliable, straightforward implementations of undo, hot code reloading, and time travel. Although these techniques are harder to implement in more traditional environments, sometimes their power is worth it. We'll walk through some hacky strategies: saving state with fork(2), replaying operations to rebuild state, and deeply copying webs of mutable objects.
Vancouver 2016
sponsored by
© 2010-2024 ConFoo. All rights reserved. Code of Conduct
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.