[REF] “The art of service discovery at scale” by Nitesh Kant

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)

Advertisements

[REF] Habitat 101: An Introduction to Habitat – July 13, 2016

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

[REF] Powering Microservices with Docker, Kubernetes, Kafka and MongoDB

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.

[REF] Best practices for orchestrating the Cloud with Kubernetes – Google I/O 2016

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.

[REF] Verifying Microservice Integrations with Contract Testing – Atlassian Summit 2016

Ben Sayers
Senior Developer, Atlassian

Mauri Edo
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.

[REF] DDD and Microservices: At Last, Some Boundaries! – Eric Evans

Presentation: DDD and Microservices: At Last, Some Boundaries!”

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.

Download Slides

References:

[1] http://gotocon.com/berlin-2015/presentation/DDD%20and%20Microservices:%20At%20Last,%20Some%20Boundaries!

[REF] Microservice Based Tool Support for Business Process Modelling

The rise of micro services as architectural pattern creates a bunch of interesting opportunities for software architectures of modelling editors and additional services. Main advantages are the scalability in collaborative distributed scenarios and enhanced possibilities regarding service development and operation. Throughout this article, we will illustrate how modelling editors and additional services can be build based on micro services. Our tooling will focus on business process modelling. We will also strive to highlight how architectures of this kind can enact collaborative modelling techniques, increase reuse of utilized service components and improve their integration into lightweight user interfaces, for example in mobile devices.

Published in: Enterprise Distributed Object Computing Workshop (EDOCW), 2015 IEEE 19th International

Authors: Sascha Alpers ; FZI Forschungszentrum Inf., Karlsruhe, Germany ; Christoph Becker ; Andreas Oberweis ; Thomas Schuster
PDF Version: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7310673

[REF] Developing Fault Tolerant Distributed Systems by Refinement

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

[REF] Efficient Tracing and Performance Analysis for Large Distributed Systems

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.

Published in:

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

[Ref] A Systematic Literature Review on Fault Prediction Performance in Software Engineering

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: Hall, T.; Beecham, S.; Bowes, D.; Gray, D.; Counsell, S.

© 2012 IEEE

Complete HTML Version: http://ieeexplore.ieee.org/xpls/icp.jsp?arnumber=6035727