logo logo

Tech Buzzwords Testers Should At Least Know About – Part 1

Tech Buzzwords Testers Should At Least Know About - Part 1

In our day to day work, we keep hearing all sorts of terms and names that relate to technology, software development, and frameworks. But sometimes we don’t have time to look up what they refer to. In this 2 part series, I did some research that will provide useful information for you to get familiar with these concepts 💡

Reactive Programming

This is something you might already be working with, without knowing that it’s called ‘reactive programming’. According to ‘Reactive Manifesto‘ this term refers to a project that provides a very good user experience, due to it being responsive. That means it needs to respond to customer requests in a timely fashion, basically as quickly as possible.

The key element of a reactive project is that its architecture is ‘message driven’. How such a system works is that the service provider is emitting a series of messages that a certain consumer is interested in. When the consumer sees the messages, it reacts to it accordingly. Other properties of a reactive project are: resilience (the system is still responsive even in case of a failure) and elastic (it can adapt its resources to handle high incoming load).

You can find more useful information about this topic in the following videos:

Apache Kafka

As I just discussed message driven systems, I will stay on the topic and discuss a bit about Apache Kafka. In a nutshell, this platform allows messages to be created and consumed between producers and consumers.

The producers will create the message, or event, which consists of a key, a value, a timestamp and some additional optional metadata. The message will be published on certain queues, called topics. Each consumer that is interested in the messages published on a topic will subscribe to it, and therefore it will have access to the topic messages. Each topic can have any number of producers and consumers. And what’s interesting, is that the events are not deleted when they are consumed ❌

The system entities, like the topics, can be configured via the Admin API. The producers will use the Producer API to create and publish the messages. The consumers will subscribe to the required topic and effectively read the events using the Consumer API.

But of course, there is much more to it. Good learning resources if you are interested in this topic are:

Cloud Native

Cloud native applications, as the name suggests, are built while having in mind that they will run on the cloud. These applications are not built as a monolith that handles all the desired functionality. Instead, the functionality is broken up into independent microservices, which interact with each other to offer the desired functionality. They run inside containers. The results of such architecture are speed, high availability, scalability, and resilience. Further explanation on this topic can be found in this Cloud Native 101 video 🎥

A Cloud Native Computing Foundation was created and it defined what cloud native applications should be. They organize a series of KubeCon + CloudNativeCon conferences, where companies which have adopted the cloud native model gather and share their experiences.


As mentioned, containers are widely used in cloud native computing. A container can be seen as a standalone entity in which the application can run. It is a process that runs on a physical machine, and it can easily be run on a VM. It contains all the files, dependencies, and configurations the application needs in order to run efficiently. Probably the most widely used container is Docker 🐳 Containers need to be managed (created & deployed) or orchestrated. The most frequently used container orchestration tool is Kubernetes.

Of course, containers can be easily used in testing. Whether it is backend testing or Selenium testing, you can use containers to set up a test environment in which to run your tests, and of course, to actually run them.

There is a lot of useful information available both on containers and orchestration, so check these out:

That’s it for this article, but don’t forget there is a second installment coming soon! Stay tuned 👀

About the author

Corina Pip

Corina is a Test & Automation Lead, with focus on testing by means of Java, Selenium, TestNG, Spring, Maven, and other cool frameworks and tools. Previous endeavours from her 11+ years testing career include working on navigation devices, in the online gaming industry, in the aviation software and automotive industries.
Apart from work, Corina is a testing blogger (https://imalittletester.com/) and a GitHub contributor (https://github.com/iamalittletester).
She is the creator of a wait based library for Selenium testing (https://github.com/iamalittletester/thewaiter) and creator of “The Little Tester” comic series (https://imalittletester.com/category/comics/). She also tweets at @imalittletester.


3 1 comment

Leave a Reply