Generate Handwritten SDKs (Sponsored)
Invest hundreds of hours your team doesn't have in maintaining SDKs by hand or generate crappy SDKs that leave a bad impression on your users. That's two bad options. Fortunately, you can now use Speakeasy to create ergonomic type-safe SDKs in over 10 languages. We've worked with language experts to create a generator that gets the details right. With Speakeasy, you can build SDKs that your team is proud of and offer code-native API docs as well.
This week’s system design refresher:
Everything You NEED to KNOW About Web Applications (Youtube video)
The Ultimate DevOps Developer Roadmap
6 Software Architectural Patterns You Must Know
Top Eventual Consistency Patterns You Must Know
SPONSOR US
Everything You NEED to KNOW About Web Applications
The Ultimate DevOps Developer Roadmap
Programming Languages
Pick and master one or two programming languages. Choose from options like Python, JavaScript, Go, Ruby, etc.
Operating Systems
Master the ins and outs of major operating systems like Linux, Windows, Mac, and so on.
Source Control Management
Learn about source control management tools such as Git, GitHub, GitLab, and Bitbucket.
Networking
Master the basics of networking concepts such as DNS, IP, TCP, and SSH.
CI/CD
Pick tools like GitHub Actions, Jenkins, or CircleCI to learn about continuous integration and continuous delivery.
Scripting and Terminals
Learn scripting in bash, and PowerShell along with knowledge of various terminals and editors.
Hosting and Platforms
Master multiple hosting platforms such as AWS, Azure, GCP, Docker, Kubernetes, Digital Ocean, Lambda, Azure Functions, etc.
Infrastructure as Code
Learn infrastructure as code tools like Terraform, Pulumi, Ansible, Chef, Puppet, Kubernetes, etc.
Monitoring and Logging
Master the key tools for monitoring and logging for infrastructure and applications such as Prometheus, Elasticsearch, Logstash, Kibana, etc.
Basics of Software Development
Learn the basics of software development such as system availability, data management, design patterns, and team collaboration.
Over to you: What else would you add to this roadmap?
New Relic unveils the industry's first Intelligent Observability Platform (Sponsored)
The New Relic Intelligent Observability Platform, transforms observability from ensuring uptime and reliability into a key driver of business growth and developer velocity for enterprises worldwide. With new innovations such as New Relic AI and GitHub Copilot integration, New Relic Pathpoint Plus for business observability, and New Relic Retail Solution.
The Ultimate Redis 101
Redis is one of the most popular data stores in the world and is packed with features.
Here are 8 simple steps that can help you understand the fundamentals of Redis.
What is Redis?
Redis (Remote Dictionary Server) is a multi-modal database that provides sub-millisecond latency. The core idea behind Redis is that a cache can also act as a full-fledged database.
Redis Adoption
High-traffic internet websites like Airbnb, Uber, Slack, and many others have adopted Redis in their technology stack.
How Redis Changed the Database Game?
Redis supported main memory read/writes while still supporting fully durable storage. Read and writes are served from the main memory but the data is also persisted to the disk. This is done using snapshots (RDB) and AOF.
Redis Data Structures
Redis stores data in key-value format. It supports various data structures such as strings, bitmaps, lists, sets, sorted sets, hash, JSON, etc.
Basic Redis Commands
Some of the most used Redis commands are SET, GET, DELETE, INCR, HSET, etc. There are many more commands available.
Redis Modules
Redis modules are add-ons that extend Redis functionality beyond its core features. Some prominent modules are RediSearch, RedisJSON, RedisGraph, RedisBloom, RedisAI, RedisTimeSeries, RedisGears, RedisML, and so on.
Redis Pub/Sub
Redis also supports even-driven architecture using a publish-subscribe communication model.
Redis Use Cases
Top Redis use cases are Distributed Caching, Session Storage, Message Queue, Rate Limiting, High-Speed Database, etc.
Over to you: What else will you add to get a better understanding of Redis?
6 Software Architectural Patterns You Must Know
Choosing the right software architecture pattern is essential for solving problems efficiently.
Layered Architecture
Each layer plays a distinct and clear role within the application context.
Great for applications that need to be built quickly. On the downside, source code can become unorganized if proper rules aren’t followed
Microservices Architecture
Break down a large system into smaller and more manageable components.
Systems built with microservices architecture are fault tolerant. Also, each component can be scaled individually. On the downside, it might increase the complexity of the application.
Event-Driven Architecture
Services talk to each other by emitting events that other services may or may not consume.
This style promotes loose coupling between components. However, testing individual components becomes challenging
Client-Server Architecture
It comprises two main components - clients and servers communicating over a network.
Great for real-time services. However, servers can become a single point of failure.
Plugin-based Architecture
This pattern consists of two types of components - a core system and plugins. The plugin modules are independent components providing a specialized functionality.
Great for applications that have to be expanded over time like IDEs. However, changing the core is difficult.
Hexagonal Architecture
This pattern creates an abstraction layer that protects the core of an application and isolates it from external integrations for better modularity. Also known as ports and adapters architecture.
On the downside, this pattern can lead to increased development time and learning curve.
Over to you: Which other architectural pattern have you seen?
Top Eventual Consistency Patterns You Must Know
Eventual consistency is a data consistency model that ensures that updates to a distributed database are eventually reflected across all nodes. Techniques like async replication help achieve eventual consistency.
However, eventual consistency can also result in data inconsistency. Here are 4 patterns that can help you design applications.
Pattern#1 - Event-based Eventual Consistency
Services emit events and other services listen to these events to update their database instances. This makes services loosely coupled but delays data consistency.
Pattern#2 - Background Sync Eventual Consistency
In this pattern, a background job makes the data across databases consistent. It results in slower eventual consistency since the background job runs on a specific schedule.
Pattern#3 - Saga-based Eventual Consistency
Saga is a sequence of local transactions where each transaction updates data with a single service. It is used to manage long-lived transactions that are eventually consistent.
Pattern#4 - CQRS-based Eventual Consistency
Separate read and write operations into different databases that are eventually consistent. Read and write models can be optimized for specific requirements.
Over to you: Which other eventual consistency patterns have you seen?
SPONSOR US
Get your product in front of more than 1,000,000 tech professionals.
Our newsletter puts your products and services directly in front of an audience that matters - hundreds of thousands of engineering leaders and senior engineers - who have influence over significant tech decisions and big purchases.
Space Fills Up Fast - Reserve Today
Ad spots typically sell out about 4 weeks in advance. To ensure your ad reaches this influential audience, reserve your space now by emailing sponsorship@bytebytego.com
