Ultimate Tech Cheat Sheet
There are a lot of different technologies, I often find myself struggling to remember all the details. There’s just so much to keep track of! To tackle this challenge, I’ve created a handy cheat sheet. It’s like a quick reference guide that I can glance at whenever I need a reminder about specific technologies. This way, I can easily refresh my memory and recall what’s what without getting overwhelmed by all the information.
If you want to keep up with the latest tech trends, this cheat sheet is here to make it easy for you to get the main points of different technical topics. I have put together short and clear explanations of important words and ideas that are the building blocks of these topics. From figuring out how Apache Kafka works to explaining what Kubernetes does, we’ve got simple answers that you’ll find really useful.
Whether you’re trying to understand the differences between SQL and NoSQL databases, exploring the idea of microservices, or learning why Java’s strings can’t be changed, you’ll find these short explanations super handy. Each section gives you a peek into the interesting world of technology, breaking down hard-to-understand words into smaller, easy-to-understand parts. You won’t need to struggle to remember what “eventual consistency” means or why “PaaS” is helpful in cloud computing.
With this cheat sheet, you’ll have a trustworthy guide to help you through all sorts of tech conversations and to remind you of various technologies.
Kafka
Kafka
Apache Kafka is an open-source distributed streaming platform that allows for the building of real-time streaming data pipelines and applications.
Topic
In Kafka, a topic is a category or feed name to which messages are published by producers and from which consumers consume messages.
Producer
A process or application that publishes messages to a Kafka topic.
Consumer
A process or application that reads and consumes messages from Kafka topics.
Message
A unit of data in Kafka, consisting of a key, value, and optional metadata.
Partition
A topic is divided into multiple partitions, which are the basic units of parallelism and scalability in Kafka.
Broker
A Kafka broker is a single instance or node in a Kafka cluster that stores and manages the partitions of the topics.
Cluster
A group of Kafka brokers working together to provide fault tolerance, high availability, and scalability.
Replication
Kafka provides the option to replicate data across multiple brokers to ensure data durability and fault tolerance.
Consumer Group
A group of consumer instances that work together to consume and process messages from one or more Kafka topics. Each partition of a topic is consumed by only one consumer within a consumer group.
Offset
Each message within a partition is assigned a unique identifier called an offset, which represents its position in the partition’s log.
Log
Kafka stores messages in a structured, distributed, and immutable commit log format. Each partition has an ordered log of messages.
Stream
A continuous, real-time flow of data in Kafka. Kafka Streams is a library that enables stream processing on Kafka topics.
Connect
Kafka Connect is a framework and set of connectors that simplifies the integration of Kafka with external systems for data import and export.
Producer API
The programming interface used to publish messages to Kafka topics programmatically.
Consumer API
The programming interface used to consume messages from Kafka topics programmatically.
Admin API
The programming interface for managing and administering Kafka topics, partitions, and other cluster metadata.
Stream Processing:The act of processing and analyzing continuous streams of data in real-time using Kafka Streams or other stream processing frameworks.
Retention
Kafka allows you to configure the retention period for topics, determining how long messages are retained before they are deleted.
Compaction
Kafka supports log compaction, a feature that retains only the most recent message for each key in a topic, which is useful for maintaining a compact history of state changes.
Kubernetes
Containerization
The process of packaging applications and their dependencies into containers for easy deployment and management.
Orchestration
The automated management and coordination of containers at scale, including scheduling, scaling, and load balancing.
Cluster
Group of machines (nodes) that collectively run containerized applications managed by Kubernetes.
Node
Physical or virtual machine that is part of a Kubernetes cluster and runs containers.
Pod
The basic unit of deployment in Kubernetes, representing one or more containers running together on a single node.
Deployment
Kubernetes resource that defines the desired state of a set of pods and manages their creation, scaling, and updates.
Service
Kubernetes resource that provides a stable network endpoint to access one or more pods, enabling load balancing and service discovery.
Namespace
Logical boundary within a Kubernetes cluster that allows for resource isolation and organization.
ReplicaSet
Kubernetes resource that ensures a specified number of identical pod replicas are running at all times.
Ingress
Kubernetes resource that manages external access to services within a cluster, typically acting as a reverse proxy.
Container Registry
Storage system for storing and distributing container images, such as Docker Hub or Amazon Elastic Container Registry (ECR).
ConfigMap and Secret
Kubernetes resources for storing and managing configuration data and sensitive information, respectively.
Operator
Kubernetes extension that encapsulates domain-specific knowledge and automates complex application management tasks.
Helm
Package manager for Kubernetes that simplifies the deployment and management of applications using pre-configured charts.
StatefulSet
Kubernetes resource for managing stateful applications that require stable network identities and persistent storage.
Kubectl
The command-line tool for interacting with Kubernetes clusters, used to deploy, manage, and troubleshoot Kubernetes resources.
Kubernetes API
The interface through which users interact with a Kubernetes cluster, allowing them to create, modify, and delete resources.
Horizontal Pod Autoscaler (HPA)
Kubernetes feature that automatically adjusts the number of pod replicas based on resource utilization.
Kubernetes Operators
Custom controllers that extend Kubernetes functionality and automate the management of complex applications or services.
Security
Email Spoofing
Sending emails that appear to be from a legitimate source to trick recipients into revealing sensitive information.
Spear Phishing
Targeted emails that are customized to deceive specific individuals or organizations.
Pharming
Redirecting users to fake websites by tampering with DNS settings or compromising servers.
Vishing
Using voice calls to trick individuals into revealing confidential information.
Smishing
Sending fraudulent text messages to trick recipients into disclosing personal information or visiting malicious links.
Clone Phishing
Creating near-identical replicas of legitimate emails to trick recipients into sharing sensitive data.
CEO Fraud
Impersonating high-ranking executives to deceive employees into making unauthorized financial transactions.
Malware-Based Phishing
Sending emails or links that contain malware to infect systems and steal sensitive information.
Search Engine Phishing
Manipulating search engine results to direct users to malicious websites or counterfeit pages.
Angler Phishing
Setting up fake customer support accounts on social media platforms to trick users into sharing personal information or login credentials.
SQL / RDBMS
Atomicity (ACID)
Transactions are treated as a single unit of work, either fully completed or rolled back if an error occurs.
Consistency (ACID)
Transactions bring the database from one valid state to another, following defined rules.
Isolation (ACID)
Concurrent transactions are executed as if they were executed sequentially, ensuring data integrity.
Durability (ACID)
Once a transaction is committed, its changes are permanent and survive any subsequent failures.
NoSQL
Basically Available
Systems remain functional even in the presence of failures, providing a basic level of availability and accessibility to data.
Soft State
Systems can tolerate temporary inconsistency or partial failures, allowing for flexible and adaptable data states.
Eventual Consistency
Over time, data replicas in different nodes synchronize, reaching a consistent state, but allowing for temporary inconsistencies during updates.
Sharding
Partitioning data across nodes for scalable and distributed storage and retrieval.
Replication
Duplicating data across nodes for availability, fault tolerance, and enhanced read performance.
SQL vs NoSQL
Data Model
SQL databases use a structured, tabular data model, while NoSQL databases employ various models like key-value, document, graph, or columnar.
Schema
SQL databases have a fixed schema that defines the structure of the data, while NoSQL databases are schema-less, allowing for flexible and dynamic data structures.
Scalability
SQL databases typically scale vertically by adding more resources to a single server, whereas NoSQL databases scale horizontally by adding more servers to distribute the load.
Query Language
SQL databases use structured query language (SQL) for querying and manipulating data, while NoSQL databases offer different query mechanisms specific to their data models.
Joins
SQL databases support complex joins between tables, whereas NoSQL databases generally do not provide explicit join operations.
ACID Compliance
SQL databases prioritize ACID (Atomicity, Consistency, Isolation, Durability) compliance for data consistency and reliability, while NoSQL databases may prioritize scalability and performance over strict consistency guarantees.
Data Relationships
SQL databases rely on explicit relationships and foreign keys to establish connections between related data, while NoSQL databases can handle relationships in different ways (embedded documents, referencing, or graph structures).
Data Distribution
SQL databases typically use a single-server architecture, while NoSQL databases are designed for distributed environments, offering built-in data replication and partitioning capabilities.
Data Flexibility
SQL databases require predefined schemas. NoSQL databases offer greater flexibility in handling evolving data structures and unstructured data, whereas
Use Cases
SQL databases are commonly used for structured and complex data, such as financial systems or reporting applications, while NoSQL databases excel in handling large-scale, real-time data, like social media feeds or IoT sensor data.
JDBC
PreparedStatement
PreparedStatement is a precompiled SQL statement that is typically used for executing parameterized queries. E.g: SELECT * FROM users WHERE username = ?
CallableStatement
CallableStatement is used to execute stored procedures or database functions. E.g: {CALL updateSalary(?, ?)}
JPA
EntityManager
Allows for the management of entity instances, persistence context, transactions, and database operations in Java applications.
Transaction-scoped Persistence
ContextDefault persistence context scope. Every time you insert something you are flushing/transaction it to DB
Extended-scoped Persistence
ContextWithout flushing you can use extended context and can flush multiple call at one time for example. More like cache based system.
Dirty Read
Read the uncommitted change of a concurrent transaction
Nonrepeatable Read
Get different value on re-read of a row if a concurrent transaction updates the same row and commits
Phantom Read
Get different rows after re-execution of a range query if another transaction adds or removes some rows in the range and commits
@Transactional
It allows us to set propagation, isolation, timeout, read-only, and rollback conditions for our transaction. We can also specify the transaction manager.
@Transactional/Propagation.REQUIRED
REQUIRED is the default propagation. Spring checks if there is an active transaction, and if nothing exists, it creates a new one.
@Transactional/Propagation.SUPPORTS
Checks if an active transaction exists. If a transaction exists, then the existing transaction will be used. If there isn’t a transaction, it is executed non-transactional
@Transactional/Propagation.MANDATORY
If there is an active transaction, then it will be used. If there isn’t an active transaction, then Spring throws an exception
@Transactional/Propagation.NEVER
Spring throws an exception if there’s an active transaction
@Transactional/Isolation.DEFAULT
Set as default and directly depends to the used RDBMS
@Transactional/Isolation.READ_UNCOMMITTED
Lowest Isolation. Most concurrent available. Has suffering from Dirty read, Nonrepeatable read, and phantom read. Postgre and Oracle does not support
@Transactional/Isolation.READ_COMMITTED
The second level of isolation, only prevents dirty reads.
@Transactional/Isolation.REPEATABLE_READ
The third level of isolation, prevents dirty, and non-repeatable reads
@Transactional/Isolation.SERIALIZABLE
Highest level of isolation. It prevents all, but can lead to the lowest concurrent access rate because it executes concurrent calls sequentially.
Spring throws an exception if there’s an active transaction
@Transactional/Isolation.DEFAULT
Set as default and directly depends to the used RDBMS
@Transactional/Isolation.READ_UNCOMMITTED
Lowest Isolation. Most concurrent available. Has suffering from Dirty read, Nonrepeatable read, and phantom read. Postgre and Oracle does not support
@Transactional/Isolation.READ_COMMITTED
The second level of isolation, only prevents dirty reads.
@Transactional/Isolation.REPEATABLE_READ
The third level of isolation, prevents dirty, and non-repeatable reads
@Transactional/Isolation.SERIALIZABLE
Highest level of isolation. It prevents all, but can lead to the lowest concurrent access rate because it executes concurrent calls sequentially.
Cloud Computing Models
PaaS
Platform as a Service. Provides a platform and environment for developing, deploying, and managing applications (Heroku, Mendix)
SaaS
Software as a Service. SaaS delivers apps online, users access and use them on remote servers via the internet.(Dropbox, Slack)
IaaS
Infrastructure as a Service. It offers virtual machines, storage, networking, and other fundamental infrastructure components as a service (AWS EC2,Google Compute Engine)
Microservices Architectural Patterns
Monolithic Architecture
Single, self-contained application with tightly coupled components.
Layered Architecture
Separates components into logical layers, such as presentation, business, and data layers.
Microkernel Architecture
Core functionalities provided by a minimal kernel, while additional services are added as plug-ins.
Event-Driven Architecture
Components communicate through events, enabling loose coupling and scalability.
Service-Oriented Architecture (SOA)
Services communicate via standardized interfaces, promoting reusability and interoperability.
Event Sourcing
Captures and stores all changes to an application’s state as a sequence of events.
Command Query Responsibility Segregation (CQRS)
Separates read and write operations, optimizing for performance and scalability.
Gateway/Backend-for-Frontend (BFF)
A single entry point for clients, allowing customization and aggregation of services.
API Gateway
Consolidates and manages multiple microservices’ APIs, providing a unified interface to clients.
Serverless Architecture
Applications run in stateless functions, eliminating the need for managing infrastructure.
Peer-to-Peer Architecture
Distributed system where nodes have equal capabilities and can directly communicate with each other.
Saga Pattern
Orchestrates multiple distributed transactions to ensure consistency across microservices.
Circuit Breaker Pattern
Provides fault tolerance by detecting failures and preventing cascading failures in distributed systems.
Event-Driven Messaging
Communication between microservices occurs through asynchronous events, enabling loose coupling and scalability.
Bulkhead Pattern
Isolates failures in one component from affecting others by using separate resources and execution paths.
Database per Service
Each microservice has its own dedicated database, promoting autonomy and decoupling of data.
Choreography
Event-driven communication pattern where microservices collaborate by broadcasting events and reacting accordingly.
Strangler Pattern
Gradually replaces a monolithic system by incrementally introducing microservices around its core functionality.
API Composition
Aggregates multiple microservices’ APIs into a single endpoint to fulfill complex client requests efficiently.
Data Replication
Copies data across multiple microservices or databases to improve availability, scalability, and performance.
Resiliency Architectural Patterns
Fault Tolerance
Ability of a system to continue functioning properly in the presence of failures.
Circuit Breaker
Mechanism that detects failures and prevents cascading failures by temporarily halting requests to a failing service.
Retry Strategy
Automatic retry of failed requests to improve the chances of success.
Bulkhead Pattern
Isolation of failures in one component from affecting others by using separate resources and execution paths.
Timeout Handling
Setting maximum response time for requests and handling timeouts to avoid resource exhaustion.
Graceful Degradation
System’s ability to gracefully degrade functionality in the face of failures or high load.
Fallback Mechanism
Providing an alternative response or behavior when a primary service is unavailable.
Load Balancing
Distributing incoming requests across multiple instances of a service to optimize performance and availability.
Rate Limiting
Limiting the number of requests a service can handle within a specific timeframe to prevent overload.
Chaos Engineering
Introducing controlled failures to test the resilience and response of a microservices architecture.
Resilience Testing
Evaluating a system’s ability to recover from failures and maintain desired functionality.
Health Monitoring
Continuous monitoring of the health and availability of microservices to detect failures.
Distributed Tracing
Capturing and analyzing requests’ paths across multiple microservices to identify performance bottlenecks and failures.
Graceful Shutdown
Ensuring a service handles ongoing requests before shutting down to prevent data loss or disruption.
Redundancy
Duplication of critical components or services to provide backup and failover capabilities.
Immutable Infrastructure
Deploying new instances instead of modifying existing ones, reducing the impact of failures and enabling easy rollback.
Data Replication
Copying and synchronizing data across multiple microservices or databases to improve availability and resilience.
Statelessness
Designing microservices to be stateless, allowing easy scaling and failure recovery.
Auto Scaling
Dynamically adjusting the number of instances based on demand to handle fluctuations in traffic and prevent overload.
Disaster Recovery
Planning and implementing strategies to recover the system after a major failure or outage.
Why Strings are immutable in Java
Efficiency
Allows the JVM to optimize memory usage. Immutable strings can be cached and shared, reducing the memory footprint of a program.
Thread safety
Multiple threads can access the same string object without the risk of data corruption or synchronization issues
Security
Strings may store sensitive information such as passwords etc. Java ensures that their values cannot be modified once created. This prevents exposing or altering sensitive data
Modern Java Related
Sequential Streams
By default, streams are sequential. Sequential streams process the elements of a stream in a specific order, one element at a time, and in a single thread
Parralel Streams
Work among multiple threads and process elements concurrently. Stream operations (e.g., filtering, mapping, reducing) are automatically parallelized managed by Java Runtime.
Functional Interfaces
Provide a mechanism for representing behavior as code and enable the use of lambda expressions and method references.
Generics
Provide type safety(Compile-time type checking), code reusability, enhanced readability, compile-time type checking, and improved flexibility in APIs.
Reduce
Performs a reduction operation on the elements of a stream and produce a single result. Arrays.asList(1, 2, 3).stream().reduce(0, (subtotal, element) -> subtotal + element);
