Ervin Varga

Apache Kafka as a Messaging Hub

A message-oriented middleware (MOM) with an associated system built on top of it is targeting scenarios where the action–reaction cycle is desirable to be separated both in space and time. This allows clients and servers to be detached from each other, and follow their intrinsic life cycle. Apache Kafka is a high performant and fault-tolerant MOM.

Architecture and Evolution

The architecture plays a central role in software engineering. This chapter will demonstrate through a case study how an architecture enables evolution. The aim is to demonstrate the following topics: Architectural Pattern, Software Reuse, Software Framework, Inversion of Control, Dependency Injection, and Test-Driven Development.

Reengineering and Reverse Engineering

Reverse engineering is about uncovering the secrets behind the product so that you may change it according to your needs. Reengineering is the process of amending the product to some new form. This chapter unifies reengineering and reverse engineering maintenance techniques into a case study and presents a flow that can be applied in practice. The aim is to illuminate how to properly proceed in extensive restructuring work.

Ad Hoc Development

Quality is usually invisible (from the viewpoint of customers and management), and many problems are only noticeable by software engineers. This chapter presents a long software development/evolution story to highlight many problems that will surface when quality is not treated seriously. It showcases how ignoring maintainability instigates an exponential growth in expenses.

Monitoring and Logging

In production, we must have visibility of what is going on within our system. Part of the DevOps culture is to share the burden of providing such supervising capability by both development and operations teams. In parallel to shipping metrics and log messages to a central location, we must also have facilities to trigger alarms if something goes awry. This chapter primarily illustrates how to properly collect/send metrics in an application and how to structure/send logs toward the appropriate infrastructure node. The aim is to showcase techniques of squeezing out the maximum insight with minimal effort (expressed in data collection, transmission, and processing time as well as cost).

Maintainability and Development

During development and maintenance, software engineers spend most of their time reasoning about the system. To speed up this activity, we need to employ a proper architecture and a straightforward implementation. This chapter shows how maintainability as a quality attribute directly supports safety and demonstrates the following concepts: Single Level of Abstraction, Layered Design, Cyclomatic Complexity, Safety Argument, and Programming in Intentions.

Scale of Deployment

DevOps are an abyss-crossing movement, like Test-Driven Development regarding testability, where deployability and observability are treated as architecturally significant quality attributes. This entails connecting construction with deployment and operational aspects of the produced system. This chapter introduces some key technologies and tools to scale the deployment of a system that is developed using the DevOps paradigm.

Multifaceted Loose Coupling

Coupling as a notion has many sides (common, data, control, environmental, etc.); thus, dozens of metrics are associated with this concept. From the perspective of automated deployment/delivery, we are most interested in how to differentiate between logical and physical coupling. This chapter revisits what the preconditions are to attain physically loosely coupled solutions and what the benefits are.

Context, Rules, and Principles

Context awareness is like defensive programming in a sense that it creates a powerful feedback loop and control mechanism to reinforce or reject an action or idea. This chapter explains the interplay between context and knowledge (partly embodied as a set of rules and principles), as well as give examples of how things can turn upside down when actions are thoughtlessly executed. The aim of this chapter is to demonstrate the following concepts: context, rules, and principles.

Implementing Messaging APIs

XML and JSON are language-independent and generic message formats, but they lag behind binary formats in efficiency. When you need to craft a system capable of processing high volumes of data, switching to a binary representation is a viable approach.