Nitesh Kant @NiteshKant / Netflix
Whether it is a simple DNS lookup or a complex dedicated solution, service discovery is the backbone of any microservices architecture and an immature solution can soon turn into an achilles’ heel.
Nitesh Kant in this talk will introduce the concept of service discovery and various use cases it solves in a complex service based architecture. He will then be introducing Netflix’s Eureka (https://github.com/Netflix/eureka); a highly-available, multi-datacenter aware service discovery solution built from scratch, it’s architecture and how it is unique in this space, by favoring Availability over Consistency in the wake of network partitions.
Nitesh Kant is an engineer in Netflix’s Cloud Platform team, working on their Inter Process Communication stack. He is the author of RxNetty (https://github.com/ReactiveX/RxNetty) which forms the core of Netflix’s IPC stack. He is also a contributor to other Open source projects like Eureka
(https://github.com/Netflix/eureka) and Karyon (https://github.com/Netflix/karyon)
Joshua Timberman / Software Development Engineer III at Chef Software
Habitat is an open-source framework that gives modern application teams an application-centric automation platform. Build, deploy, and manage modern and legacy applications with Habitat. In this talk we will explore:
– Introduction to Habitat
– The problems Habitat solves
– Getting started with Habitat Plans
– Using Habitat in your Chef workflow
Andrew Morgan / Principal Product Marketing Manager on MongoDB
Organisations are building their applications around microservice architectures because of the flexibility, speed of delivery, and maintainability they deliver. This session introduces you to technologies such as Docker, Kubernetes & Kafka which are driving the microservices revolution. Learn about containers and orchestration – and most importantly how to exploit them for stateful services such as MongoDB.
Carter Morgan / Developer Programs Engineer at Google
In the last decade, user demand for always-on applications have grown exponentially. Many developers choose application patterns to meet this need, but what about the infrastructure needed to support these ever growing demands? In this talk, we introduce you to the next level of automation using hands-on examples of industry standard tooling like Docker, a container format, and Kubernetes, a distributed automation platform. We cover the basics of modern day applications and how design patterns like microservices drive the need for more robust infrastructure. Then we cover packaging and distributing apps using Docker. Finally, we up our game to running applications on Kubernetes. By the end of this talk you’ll have the knowledge needed to excel at scale.
Senior Developer, Atlassian
QA Engineer, Atlassian
As you migrate your applications toward microservice architectures, new pains start to appear – like testing, for example. How on Earth do you verify all these separate moving parts work together before releasing? How can you be sure that your code is compatible with services that can’t easily be spun up anymore? They are all written in different languages, operated by separate teams and deploy every day!
Do you find yourself lying awake at night missing monolithic applications where integrations were easier to test? In this talk we’ll reveal how Atlassian is adopting a new strategy called “contract testing”, using the Pact open source library to test our microservices. We’ll introduce the concept of contract testing, talk about why we love this approach, and go through some examples and patterns that will help you get started.
Microservices are associated with extreme isolation (e.g. no shared database, autonomous dev-ops teams, etc.) At its best, this creates a practical boundary within which modeling and design have a chance to thrive. In Domain-driven Design (DDD) we call this a “Bounded Context”. Bounded contexts take many forms, some leakier than others, and the current best practices of microservices have given us perhaps the strongest mainstream manifestation of this principle to date. In this way, microservices can help teams who attempting DDD or other sophisticated approaches.Yet, as services get small and numerous, we might substitute one problem for another: The tangle of the monolith just migrates to become a tangle of interactions between microservices. Here, the strategic design principles of DDD can give architects a conceptual framework for working with suites of services and higher-level relationships between larger parts of systems.
This talk will introduce a few strategic design concepts and explain how they apply to development of microservices, as a tool for teams trying to grow large systems more coherently.
Distributed systems are usually large and complex systems composed of various components. Systemcomponents are subject to various errors. These failures often require error recovery to be conducted at architectural-level. However, due to complexity of distributed systems, specifying fault tolerance mechanisms at architectural level is complex and error prone. In this paper, we propose a formal approach to specifying components and architectures of fault tolerant distributed and reactive systems. Our approach is based on refinement in the action system formalism – a framework for formal model-driven development of distributed systems. We demonstrate how to specify and refine fault tolerant components and complex distributed systems composed of them. The proposed approach provides designers with a systematic method for developing distributed fault tolerant systems.
Published in: Software Engineering Advances (ICSEA), 2010 Fifth International Conference on
Author: Elena Troubitsyna ; Dept. of IT, Abo Akademi Univ., Turku, Finland
PDF Version: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=5615742
Distributed systems are notoriously difficult to implement and debug. One important tool for understanding the behavior of distributed systems is tracing. Unfortunately, effective tracing for moderndistributed systems faces several challenges. First, many interesting behaviors in distributed systemsonly occur rarely, or at full production scale. Hence we need tracing mechanisms which impose minimal overhead, in order to allow always-on tracing of production instances. Second, for high-speed systems, messages can be delivered in significantly less time than the error of traditional time synchronization techniques such as network time protocol (NTP), necessitating time adjustment techniques with much higher precision. Third, distributed systems today may generate millions of events per second systemwide, resulting in traces consisting of billions of events. Such large traces can overwhelm existing trace analysis tools. These challenges make effective tracing difficult. We present techniques that address these three challenges. Our contributions include (1) a low-overhead tracing mechanism, which allows tracing of large systems without impacting their behavior or performance (0.14 Â¿s/event), (2) a post hoc technique for producing highly accurate time synchronization across hosts (within 10/ts, compared to between 100 Â¿s to 2 ms for NTP), and (3) incremental data processing techniques which facilitate analyzing traces containing billions of trace points on desktop systems. We have successfully applied these techniques to two distributed systems, a cooperative caching systemand a distributed storage system, and from our experience, we believe our techniques are applicable to other distributed systems.
Modeling, Analysis & Simulation of Computer and Telecommunication Systems, 2009. MASCOTS ’09. IEEE International Symposium on
AUTHORS: Eric Anderson ; Christopher Hoover ; Xiaozhou Li ; Joseph Tucek
PDF VERSION: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=536615
Background: The accurate prediction of where faults are likely to occur in code can help direct test effort, reduce costs, and improve the quality of software. Objective: We investigate how the context of models, the independent variables used, and the modeling techniques applied influence the performance of fault prediction models. Method: We used a systematic literature review to identify 208 fault prediction studies published from January 2000 to December 2010. We synthesize the quantitative and qualitative results of 36 studies which report sufficient contextual and methodological information according to the criteria we develop and apply. Results: The models that perform well tend to be based on simple modeling techniques such as Naive Bayes or Logistic Regression. Combinations of independent variables have been used by models that perform well. Feature selection has been applied to these combinations when models are performing particularly well. Conclusion: The methodology used to build models seems to be influential to predictive performance. Although there are a set of fault prediction studies in which confidence is possible, more studies are needed that use a reliable methodology and which report their context, methodology, and performance comprehensively.
This paper appears in: Software Engineering, IEEE Transactions on, Issue Date: Nov.-Dec. 2012, Written by:
© 2012 IEEE
Complete HTML Version: http://ieeexplore.ieee.org/xpls/icp.jsp?arnumber=6035727