Nikki Siapno

How do we design effective and safe APIs?

APIs have increasingly become the backbone of modern software.

𝗧𝗼 𝘂𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱 some of the 𝗸𝗲𝘆 𝗽𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 and 𝗯𝗲𝘀𝘁 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀 𝗼𝗳 𝗔𝗣𝗜 𝗱𝗲𝘀𝗶𝗴𝗻, Let's 𝗮𝗻𝗮𝗹𝘆𝘇𝗲 𝗮 𝘀𝗼𝗰𝗶𝗮𝗹 𝗺𝗲𝗱𝗶𝗮 𝗽𝗹𝗮𝘁𝗳𝗼𝗿𝗺 𝗲𝘅𝗮𝗺𝗽𝗹𝗲:

🔹 𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲 𝗻𝗮𝗺𝗶𝗻𝗴
↳ Clarity is key when creating APIs. Adopting simple resource names, like /users for accessing user profiles and /posts for retrieving user posts, streamlines the development process and reduces mental strain.

🔹 𝗨𝘀𝗲 𝗼𝗳 𝗽𝗹𝘂𝗿𝗮𝗹𝘀
↳ It's important to maintain a standard of consistency in API design. For consistency and readability, use plural resource names, such as GET /users/{userId}/friends vs. /friend), to avoid ambiguity in API requests.

🔹 𝗖𝗿𝗼𝘀𝘀-𝗿𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗶𝗻𝗴 𝗿𝗲𝘀𝗼𝘂𝗿𝗰𝗲𝘀
↳ Interlinking resources, like taking comments on a post using GET /posts/{postId}/comments, simplifies the retrieval of related data. It provides a more streamlined and well-organized user experience.

🔹 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆
↳ It goes without saying, security is a must-have. To secure the API endpoints, employ authentication methods like X-AUTH-TOKEN and X-SIGNATURE, and use authorization headers for verifying user permissions.

🔹 𝗩𝗲𝗿𝘀𝗶𝗼𝗻𝗶𝗻𝗴
↳ Using versioning and communicating version updates is another important practice. Endpoints like GET /v2/users/{userId}/posts allow API versioning to maintain functionality regardless of updates. This approach ensures backward compatibility and a smooth transition for users and us.

🔹 𝗣𝗮𝗴𝗶𝗻𝗮𝘁𝗶𝗼𝗻
↳ This technique is important for performance. Paginate large datasets, like feeds or comment lists, with GET /posts?page=5&pageSize=20 to enhance data delivery and UX.

🔹 𝗜𝗱𝗲𝗺𝗽𝗼𝘁𝗲𝗻𝗰𝘆
↳ Maintaining API reliability is necessary. Idempotency ensures that operations like profile updates (PUT /users/{userId}/profile) achieve their intended result, regardless of how often they are executed.

Thorough documentation, robust monitoring and logging, and consistent error handling are just a few more of the many essential habits required for designing effective and safe APIs.

Adopting these principles and practices enables us to develop secure and performant APIs that deliver good user experiences.

💭 Over to you. What would you add? 💬

~~
Thanks to our partner CodeRabbit who keeps our content free to the community.

VS Code, Cursor, Windsurf. CodeRabbit now runs natively across them all. They're providing 𝘂𝗻𝗹𝗶𝗺𝗶𝘁𝗲𝗱 𝗳𝗿𝗲𝗲 𝗔𝗜 𝗰𝗼𝗱𝗲 𝗿𝗲𝘃𝗶𝗲𝘄𝘀 𝗱𝗶𝗿𝗲𝗰𝘁𝗹𝘆 𝗶𝗻 𝘁𝗵𝗲 𝗜𝗗𝗘. (rate limits apply).

Check it out (it's free): https://lnkd.in/gwSBkvRc

8 Popular Network Protocols Explained.

Network protocols operate at different layers of the OSI model. The protocols below operate at different layers, this is important to note.

The OSI model is a conceptual framework that defines a networking system as a series of layers, each with specific functions, to facilitate the transfer, management, and processing of data in a network.

This layered architecture ensures standardized interactions between various software and hardware components in a network.

𝗧𝗖𝗣/𝗜𝗣 (𝗧𝗿𝗮𝗻𝘀𝗺𝗶𝘀𝘀𝗶𝗼𝗻 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹/𝗜𝗻𝘁𝗲𝗿𝗻𝗲𝘁 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹)

This protocol is the underlying method of how information is passed between devices on the internet. While IP is responsible for addressing and routing data packets, TCP takes care of assembling the data into packets, as well as reliable delivery.

𝗛𝗧𝗧𝗣 (𝗛𝘆𝗽𝗲𝗿𝘁𝗲𝘅𝘁 𝗧𝗿𝗮𝗻𝘀𝗳𝗲𝗿 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹)

When accessing websites, HTTP plays a crucial role. It's responsible for fetching and delivering web content from servers to end-users.

𝗛𝗧𝗧𝗣𝗦 (𝗛𝘆𝗽𝗲𝗿𝘁𝗲𝘅𝘁 𝗧𝗿𝗮𝗻𝘀𝗳𝗲𝗿 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 𝗦𝗲𝗰𝘂𝗿𝗲)

An enhanced version of HTTP, HTTPS integrates security protocols (namely TLS) to encrypt data, ensuring a secure and confidential exchange between browsers and websites.

𝗙𝗧𝗣 (𝗙𝗶𝗹𝗲 𝗧𝗿𝗮𝗻𝘀𝗳𝗲𝗿 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹)

As the name suggests, FTP is used for transferring files (uploading and downloading) between computers on a network.

𝗨𝗗𝗣 (𝗨𝘀𝗲𝗿 𝗗𝗮𝘁𝗮𝗴𝗿𝗮𝗺 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹)

A more streamlined counterpart to TCP, UDP transmits data without the overhead of establishing a connection, leading to faster transmission but without the guarantee that the data will be delivered or in order.

𝗦𝗠𝗧𝗣 (𝗦𝗶𝗺𝗽𝗹𝗲 𝗠𝗮𝗶𝗹 𝗧𝗿𝗮𝗻𝘀𝗳𝗲𝗿 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹)

The driving force behind email communication, SMTP manages the formatting, routing, and delivery of emails between mail servers.

𝗦𝗦𝗛 (𝗦𝗲𝗰𝘂𝗿𝗲 𝗦𝗵𝗲𝗹𝗹)

Secure Shell is a cryptographic network protocol that ensures safe data transmission over an unsecured network. It provides a safe channel, making sure that hackers can't interpret the information by eavesdropping.

💬 I'd love to hear your thoughts, are there any other protocols or concepts you'd like to add?

~~
Thank you to our partner Kickresume who keeps our content free to the community.

Seeing other successful software engineering resumes is big help in ensuring your own is crafted well.

Kickresume has a library of high-quality SWE resumes that got people hired.

Check them out: https://lnkd.in/gba7FQhr

CSS em vs rem explained 🎨👇

Both em and rem are relative units of measurement used in frontend development.

em is relative to the font size of the parent element.

rem is relative to the font size of the root element.

——

Want more programming concepts visually explained like this?

Subscribe to our 𝐟𝐫𝐞𝐞 𝐧𝐞𝐰𝐬𝐥𝐞𝐭𝐭𝐞𝐫 for a weekly deep-dive and roundup of all our best content → blog.levelupcoding.co

#webdevelopment #programming #css

CI/CD Pipelines — How Do You Optimize Their Performance?

CI/CD pipelines allow development teams to 𝗱𝗲𝗹𝗶𝘃𝗲𝗿 𝗰𝗵𝗮𝗻𝗴𝗲𝘀 𝗾𝘂𝗶𝗰𝗸𝗹𝘆 𝗮𝗻𝗱 𝗰𝗼𝗻𝗳𝗶𝗱𝗲𝗻𝘁𝗹𝘆.

Poorly performing pipelines lead to an increase in deployment times, opens up the risk of errors, and lowers developer productivity.

Before we explore the effective solutions to boost the performance of CI/CD pipelines, take a moment to revise the many components involved with the attached visual; this knowledge will help identify improvements.

Once you've reviewed that, let’s dive in:

The first step in optimizing any system is to analyze its processes and 𝗶𝗱𝗲𝗻𝘁𝗶𝗳𝘆 𝘁𝗵𝗲 𝗯𝗼𝘁𝘁𝗹𝗲𝗻𝗲𝗰𝗸𝘀 𝗮𝗻𝗱 𝗶𝗻𝗲𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝗰𝗶𝗲𝘀.

A common culprit to poor performance is the 𝗹𝗮𝗰𝗸 𝗼𝗳 𝗽𝗮𝗿𝗮𝗹𝗹𝗲𝗹𝗶𝘀𝗺. Take a look at the processes that run in sequence and consider if they could instead run in parallel. This simple change could mean a drastic reduction in deployment times.

The order in which tests are executed is often an overlooked factor but something that can impact performance. While there are best practices to follow, the best approach will vary per project. It's important to find a balance between 𝗲𝗮𝗿𝗹𝘆 𝗳𝗲𝗲𝗱𝗯𝗮𝗰𝗸 𝗮𝗻𝗱 𝗲𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝗰𝘆. If possible, 𝗼𝗻𝗹𝘆 𝗿𝘂𝗻 𝘁𝗲𝘀𝘁𝘀 𝘁𝗵𝗮𝘁 𝗿𝗲𝗹𝗮𝘁𝗲 𝘁𝗼 𝘁𝗵𝗲 𝘀𝗲𝘁 𝗼𝗳 𝗰𝗵𝗮𝗻𝗴𝗲𝘀; but be careful — don't overly complicate your test suite.

Another common culprit is the build process. Check the efficiency of your 𝗯𝘂𝗶𝗹𝗱 𝘀𝗰𝗿𝗶𝗽𝘁𝘀, 𝗿𝗲𝗺𝗼𝘃𝗲 𝘂𝗻𝗻𝗲𝗰𝗲𝘀𝘀𝗮𝗿𝘆 𝗱𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝗶𝗲𝘀, 𝗮𝗻𝗱 𝗰𝗮𝗰𝗵𝗲 𝗮𝗿𝘁𝗶𝗳𝗮𝗰𝘁𝘀. Try to avoid any unnecessary processes, especially if the assets needed can be pulled from the previous build.

Finally, analyze and ensure the 𝗶𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 can support your pipeline. Ensure that it has adequate resources and can scale as needed.

A CI/CD pipeline is integral to any development process and one that impacts the development team’s day-to-day operations. It's important to invest time and effort to ensure your pipeline stays optimal as it can have an ongoing impact on the team’s productivity.

——

𝗔 𝗯𝗶𝗴 𝘁𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝘁𝗼 𝗼𝘂𝗿 𝗽𝗮𝗿𝘁𝗻𝗲𝗿 𝗣𝗼𝘀𝘁𝗺𝗮𝗻 𝘄𝗵𝗼 𝗸𝗲𝗲𝗽𝘀 𝗼𝘂𝗿 𝗰𝗼𝗻𝘁𝗲𝗻𝘁 𝗳𝗿𝗲𝗲 𝘁𝗼 𝘁𝗵𝗲 𝗰𝗼𝗺𝗺𝘂𝗻𝗶𝘁𝘆.

Postman provides full support for GraphQL. They even have an examples feature to store request/response pairs and illustrate how your GraphQL requests work.

Check it out: https://lnkd.in/dCa-kAZd

What is Kafka?

Apache Kafka is an open source distributed streaming platform designed for building real-time data pipelines and streaming applications.

Kafka operates as a 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗽𝘂𝗯-𝘀𝘂𝗯 𝗺𝗲𝘀𝘀𝗮𝗴𝗶𝗻𝗴 𝘀𝘆𝘀𝘁𝗲𝗺. Allowing applications to publish and subscribe to real-time or near-real-time data feeds. The 𝗵𝗶𝗴𝗵 𝘁𝗵𝗿𝗼𝘂𝗴𝗵𝗽𝘂𝘁, 𝘀𝗰𝗮𝗹𝗮𝗯𝗶𝗹𝗶𝘁𝘆, 𝗳𝗮𝘂𝗹𝘁-𝘁𝗼𝗹𝗲𝗿𝗮𝗻𝗰𝗲, 𝗱𝘂𝗿𝗮𝗯𝗶𝗹𝗶𝘁𝘆, and 𝗲𝗰𝗼𝘀𝘆𝘀𝘁𝗲𝗺 𝗞𝗮𝗳𝗸𝗮 𝗽𝗿𝗼𝘃𝗶𝗱𝗲𝘀 have made it a very 𝗽𝗼𝗽𝘂𝗹𝗮𝗿 𝗰𝗵𝗼𝗶𝗰𝗲 𝗳𝗼𝗿 use cases where 𝗿𝗲𝗮𝗹-𝘁𝗶𝗺𝗲 𝗱𝗮𝘁𝗮 𝗳𝗲𝗲𝗱𝘀 are required.

𝗧𝗵𝗲 𝗸𝗲𝘆 𝗰𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝘀 𝗼𝗳 𝗞𝗮𝗳𝗸𝗮 𝗶𝗻𝗰𝗹𝘂𝗱𝗲:

🔸 𝗣𝗿𝗼𝗱𝘂𝗰𝗲𝗿
Producers publish (write) messages to a Kafka topic.
🔸 𝗖𝗼𝗻𝘀𝘂𝗺𝗲𝗿
Consumers/subscribers subscribe to topics and process (read) the feed of published messages.
🔸 𝗕𝗿𝗼𝗸𝗲𝗿
Brokers are Kafka servers that store data and serve clients. Multiple brokers form a cluster.
🔸 𝗧𝗼𝗽𝗶𝗰
Topics are a feed name or message category to which messages are published by producers.
🔸 𝗣𝗮𝗿𝘁𝗶𝘁𝗶𝗼𝗻
Messages are organized into topics, which can then be further divided into partitions. This increases parallelism and scalability allowing consumers to read different partitions at the same time.

𝗞𝗮𝗳𝗸𝗮 𝗰𝗮𝗻 𝗯𝗲 𝘂𝘀𝗲𝗱 𝗳𝗼𝗿 𝗺𝗮𝗻𝘆 𝘂𝘀𝗲 𝗰𝗮𝘀𝗲𝘀. A few of the more common 𝘂𝘀𝗲 𝗰𝗮𝘀𝗲𝘀 𝗶𝗻𝗰𝗹𝘂𝗱𝗲:

🔹 𝗔𝗴𝗴𝗿𝗲𝗴𝗮𝘁𝗶𝗻𝗴 𝗱𝗮𝘁𝗮 𝗳𝗿𝗼𝗺 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝘀𝗼𝘂𝗿𝗰𝗲𝘀: Whether it's ETL pipelines, data lakes, or log aggregation; ingesting, organizing, transforming, and distributing data are core functions of Kafka.
🔹 𝗦𝘁𝗿𝗲𝗮𝗺 𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴: Kafka can be used to build real-time analytics applications.
🔹 𝗘𝘃𝗲𝗻𝘁 𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴: systems or applications that rely on processing events in real-time such as IoT devices.
🔹 𝗠𝗼𝗻𝗶𝘁𝗼𝗿𝗶𝗻𝗴: Kafka is well suited for storing logs and metrics, allowing for real-time monitoring and alerts.

Designed for fault tolerance, high throughput, durability, and scalability, Kafka serves as an intermediary service for handling large data. While Kafka provides many advantages for building real-time data pipelines and streaming applications, it's not without its drawbacks. The most noteworthy being the layers of complexity it adds to the system architecture. In saying that, if real-time data feed is required, Kafka is a popular choice.

——

A big thank you to our partner Postman who keeps this content free to our readers.

Wish you could test your API without leaving your code editor? Postman’s new VS Code extension lets you do exactly that!

Check it out: https://lnkd.in/gdFSHMu4

#softwareengineering #programming #systemdesign

How to Use Big O to Ace Your Technical Interviews:

Firstly, what is Big O Notation?

Big O describes an algorithm's runtime or memory consumption without the interference of contextual variables like RAM and CPU. It gives programmers a way to compare algorithms and identify the most efficient solution.

𝗕𝗶𝗴 𝗢 𝗮𝗻𝘀𝘄𝗲𝗿𝘀 𝗼𝗻𝗲 𝘀𝘁𝗿𝗮𝗶𝗴𝗵𝘁𝗳𝗼𝗿𝘄𝗮𝗿𝗱 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻:

“How much does runtime or memory consumption grow as the size of the input increases, in the worst-case scenario?“.

𝗧𝗼 𝘂𝘁𝗶𝗹𝗶𝘇𝗲 𝗕𝗶𝗴 𝗢, you'll need to know the possible values and how they compare with each other. Use the attached photo for a quick reference.

𝗦𝗼, 𝗵𝗼𝘄 𝗱𝗼 𝘆𝗼𝘂 𝗮𝗽𝗽𝗹𝘆 𝗕𝗶𝗴 𝗢 𝗶𝗻 𝘆𝗼𝘂𝗿 𝘁𝗲𝗰𝗵𝗻𝗶𝗰𝗮𝗹 𝗶𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄𝘀?

Here are a few scenarios where Big O can be used:

🔸 Live coding challenges
🔸 Code walk-throughs
🔸 Discussions about projects/solutions you've built
🔸 Discussions about your approach to programming & problem-solving

When any of these scenarios come up, be sure to mention the Big O of your solution and how it compares to alternative approaches. This is especially useful in live coding challenges where you have to compare solutions on the spot — remember to think out loud!

𝗧𝗶𝗽: 𝗪𝗵𝗲𝗻 𝗰𝗼𝗺𝗽𝗮𝗿𝗶𝗻𝗴 𝘀𝗼𝗹𝘂𝘁𝗶𝗼𝗻𝘀, 𝗽𝗮𝘆 𝗮𝘁𝘁𝗲𝗻𝘁𝗶𝗼𝗻 𝘁𝗼 𝘁𝗵𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺'𝘀 𝗿𝗲𝗾𝘂𝗶𝗿𝗲𝗺𝗲𝗻𝘁𝘀.

For example, linear time complexity may be completely fine when the input can never be too large. But if you’re dealing with big data, you’ll want to opt for something more efficient.

Of course, the goal is to get the correct Big O notation that applies to your solution. But don't worry about getting it wrong! Your interviewer will probably correct you when you do. The point is to show that you are thinking about the efficiency and performance of your solution.

𝗗𝗼 𝘁𝗵𝗶𝘀 𝗮𝗻𝗱 𝘆𝗼𝘂'𝗹𝗹 𝗯𝗲 𝗮𝗯𝗹𝗲 𝘁𝗼 𝘀𝗵𝗼𝘄𝗰𝗮𝘀𝗲 𝗮𝗻 𝗶𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁 𝘁𝗿𝗮𝗶𝘁 𝘁𝗵𝗮𝘁 𝘁𝗲𝗰𝗵𝗻𝗶𝗰𝗮𝗹 𝗵𝗶𝗿𝗶𝗻𝗴 𝗺𝗮𝗻𝗮𝗴𝗲𝗿𝘀 𝗹𝗼𝗼𝗸 𝗳𝗼𝗿:

The ability to consider a solution's viability beyond whether it works or not. This shows maturity in your decision-making and approach to programming.

——

𝗔 𝗯𝗶𝗴 𝘁𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝘁𝗼 𝗼𝘂𝗿 𝗽𝗮𝗿𝘁𝗻𝗲𝗿 𝗣𝗼𝘀𝘁𝗺𝗮𝗻 𝘄𝗵𝗼 𝗸𝗲𝗲𝗽𝘀 𝗼𝘂𝗿 𝗰𝗼𝗻𝘁𝗲𝗻𝘁 𝗳𝗿𝗲𝗲 𝘁𝗼 𝘁𝗵𝗲 𝗰𝗼𝗺𝗺𝘂𝗻𝗶𝘁𝘆.

If you’re building or working with REST APIs, Postman’s REST client makes the process much easier. It’s free to use as well.

You can read more about it here: https://lnkd.in/g2QQ-sxS

The most popular database caching strategies explained.

Database caching plays a crucial role in enhancing application performance by optimizing data retrieval.

By caching frequently requested data, this technique reduces latency and accelerates queries, leading to more responsive and efficient systems.

𝗟𝗲𝘁'𝘀 𝗹𝗼𝗼𝗸 𝗮𝘁 𝗳𝗶𝘃𝗲 𝗼𝗳 𝘁𝗵𝗲 𝗺𝗼𝘀𝘁 𝗰𝗼𝗺𝗺𝗼𝗻 𝗺𝗲𝘁𝗵𝗼𝗱𝘀:

🔹 𝗖𝗮𝗰𝗵𝗲-𝗮𝘀𝗶𝗱𝗲 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆

This strategy grants applications explicit control over the caching process.

Applications check the cache before the database, enabling precise control suited to dynamic data or irregular access patterns.

However, this approach requires manual cache management, which can increase complexity.

🔹 𝗪𝗿𝗶𝘁𝗲-𝘁𝗵𝗿𝗼𝘂𝗴𝗵 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆

By simultaneously writing to the cache and the database, this technique guarantees data consistency.

For applications requiring high data reliability, it eliminates inconsistencies and ensures immediate cache availability, despite increased write latency.

🔹 𝗪𝗿𝗶𝘁𝗲-𝗯𝗲𝗵𝗶𝗻𝗱 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆

Write performance is improved by caching data first and updating the database asynchronously—a strategy that prioritizes speed over immediate consistency.

This approach boosts responsiveness and reduces database load but risks data loss if the cache expires before syncing.

Applications that can handle delayed data consistency and demand fast write speeds are best suited for it.

🔹 𝗥𝗲𝗮𝗱-𝘁𝗵𝗿𝗼𝘂𝗴𝗵 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆

When a cache misses, this strategy stores data in the cache by automatically retrieving it from the database.

While this method simplifies application code by abstracting caching procedures, initial cache misses can delay data retrieval.

It supports applications with stable data sets and high read demands by efficiently reducing database load.

🔹 𝗪𝗿𝗶𝘁𝗲-𝗮𝗿𝗼𝘂𝗻𝗱 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆

This method bypasses the cache, which is only refreshed upon further read requests, and writes data straight to the database.

It keeps space for frequently accessed data by postponing cache updates, preventing premature cache saturation.

Cache efficiency is maximized in write-intensive applications where instantaneous read access to fresh data is not essential.

Database caching greatly improves application performance by reducing latency, increasing scalability, and enhancing user experiences.

By selecting and implementing the optimal database caching solutions, we can meet unique application demands efficiently while maintaining high speed and resource efficiency.

How Do Services Communicate With Each Other?

This is an important decision when designing the implementation of any multi-service architecture.

Here's a quick guide to the most commonly used techniques, use it as a starting point for your decision:

𝗴𝗥𝗣𝗖 is an open-source remote procedure call framework developed by Google. It uses Protocol Buffers to define service and message types which make data compact and efficient to transmit and store. It supports bi-directional streaming and offers flow control features.

𝗪𝗲𝗯𝗦𝗼𝗰𝗸𝗲𝘁𝘀 provide a full-duplex channel over a TCP connection. They allow both the client and server to send messages to each other at the same time. WebSockets require an open connection which is more resource-intensive than stateless options.

𝗥𝗘𝗦𝗧𝗳𝘂𝗹 𝗔𝗣𝗜𝘀 provide an interface for services to communicate with each other. It uses the standard HTTP methods GET, POST, PATCH, and DELETE. It is stateless in nature which means requests must contain all the information required to process it.

𝗚𝗿𝗮𝗽𝗵𝗤𝗟 is another API-based approach. It is a data query and manipulation language that provides a way to consolidate APIs so that services can communicate via a single API endpoint. This simplifies communication with a consistent and unified interface.

In an 𝗲𝘃𝗲𝗻𝘁-𝗱𝗿𝗶𝘃𝗲𝗻 approach, services respond to changes in state (referred to as an event). Services send events to a message broker or an event bus which forwards the event to relevant services. This promotes loose coupling, allows services to scale independently, and improves resilience.

A 𝘀𝗲𝗿𝘃𝗶𝗰𝗲 𝗺𝗲𝘀𝗵 adds an infrastructure layer to each service. It adds a network proxy (called a sidecar) where network traffic is routed through. Because it does this to each individual service, features such as authentication and load balancing can be done on a very granular level.

Choosing the right approach for a system can be challenging, given the many options available and their varying use cases. Understanding your system’s requirements is essential, and often the best approach requires a mix of the options above to accommodate for different components in your system.

——

A big thank you to our partner Postman who keeps this content free to our readers.

VS Code and Postman are no longer adjacent tools, they’re now fully integrated! The long-awaited VS Code extension from Postman has been released.

Check it out: https://lnkd.in/gdFSHMu4

HTTP status codes explained:

When a server receives a request from a client, it provides a response that includes both the requested data and a 3-digit 𝘀𝘁𝗮𝘁𝘂𝘀 𝗰𝗼𝗱𝗲 that succinctly 𝗰𝗼𝗺𝗺𝘂𝗻𝗶𝗰𝗮𝘁𝗲𝘀 𝘁𝗵𝗲 𝗿𝗲𝗾𝘂𝗲𝘀𝘁'𝘀 𝗼𝘂𝘁𝗰𝗼𝗺𝗲 𝗼𝗿 𝘀𝘁𝗮𝘁𝘂𝘀.

Clients use these standardized sets of codes to determine if a request has been properly handled, whether more action is required, or whether an error has occurred.

HTTP status codes are 𝗱𝗶𝘃𝗶𝗱𝗲𝗱 𝗶𝗻𝘁𝗼 𝗳𝗶𝘃𝗲 𝗰𝗮𝘁𝗲𝗴𝗼𝗿𝗶𝗲𝘀, each 𝗶𝗱𝗲𝗻𝘁𝗶𝗳𝗶𝗲𝗱 𝗯𝘆 𝘁𝗵𝗲 𝗳𝗶𝗿𝘀𝘁 𝗱𝗶𝗴𝗶𝘁 𝗼𝗳 𝘁𝗵𝗲 𝗰𝗼𝗱𝗲:

🟣 𝗜𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻𝗮𝗹 (𝟭𝘅𝘅): The request was received, and the process is continuing.
🟢 𝗦𝘂𝗰𝗰𝗲𝘀𝘀 (𝟮𝘅𝘅): The request was successfully received, understood, and accepted.
🔵 𝗥𝗲𝗱𝗶𝗿𝗲𝗰𝘁𝗶𝗼𝗻 (𝟯𝘅𝘅): The request needs further action to be completed.
🟠 𝗖𝗹𝗶𝗲𝗻𝘁 𝗘𝗿𝗿𝗼𝗿 (𝟰𝘅𝘅): The request contains incorrect syntax or cannot be fulfilled by the server.
🔴 𝗦𝗲𝗿𝘃𝗲𝗿 𝗘𝗿𝗿𝗼𝗿 (𝟱𝘅𝘅): The server failed to fulfill a valid request.

𝗧𝗵𝗲 𝗺𝗼𝘀𝘁 𝗶𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁/𝗰𝗼𝗺𝗺𝗼𝗻 𝗳𝗼𝗿 𝗲𝗮𝗰𝗵 𝗰𝗮𝘁𝗲𝗴𝗼𝗿𝘆 𝗮𝗿𝗲 𝗹𝗶𝘀𝘁𝗲𝗱 𝗶𝗻 𝘁𝗵𝗲 𝘃𝗶𝘀𝘂𝗮𝗹 𝗯𝗲𝗹𝗼𝘄.

Server 𝘀𝘁𝗮𝘁𝘂𝘀 𝗰𝗼𝗱𝗲𝘀 for HTTP 𝘀𝗲𝗿𝘃𝗲 𝘀𝗲𝘃𝗲𝗿𝗮𝗹 𝗸𝗲𝘆 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 in web development including:

🔸 Efficient communication
🔸 Reliability and troubleshooting
🔸 Error identification
🔸 Facilitating automation
🔸 Providing user feedback
🔸 And much more…

Below are some 𝗯𝗲𝘀𝘁 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀 𝗳𝗼𝗿 𝘄𝗼𝗿𝗸𝗶𝗻𝗴 𝘄𝗶𝘁𝗵 𝘀𝘁𝗮𝘁𝘂𝘀 𝗰𝗼𝗱𝗲𝘀:

🔹 𝗨𝘀𝗲 𝘀𝗽𝗲𝗰𝗶𝗳𝗶𝗰 𝘀𝘁𝗮𝘁𝘂𝘀 𝗰𝗼𝗱𝗲𝘀: Use the most specific status code that accurately describes the outcome of an operation.
🔹 𝗕𝗲 𝗰𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝘁: Maintain consistency in how you use status codes across your application.
🔹 𝗜𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁 𝗰𝘂𝘀𝘁𝗼𝗺 𝗲𝗿𝗿𝗼𝗿 𝗺𝗲𝘀𝘀𝗮𝗴𝗲𝘀: Send additional info in the response body or headers to provide more context.
🔹 𝗟𝗼𝗴 𝗮𝗻𝗱 𝗺𝗼𝗻𝗶𝘁𝗼𝗿: Logging and monitoring of the status codes your app is sending and receiving can help in performance tuning, detecting anomalies, and debugging.

Although HTTP status codes may seem like a small and simple aspect of web development, they play an indispensable role in client, server communication. Understanding and utilizing the status codes effectively is a fundamental part of developing sound applications.

——

𝗔 𝗯𝗶𝗴 𝘁𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝘁𝗼 𝗼𝘂𝗿 𝗽𝗮𝗿𝘁𝗻𝗲𝗿 𝗣𝗼𝘀𝘁𝗺𝗮𝗻 𝘄𝗵𝗼 𝗸𝗲𝗲𝗽𝘀 𝗼𝘂𝗿 𝗰𝗼𝗻𝘁𝗲𝗻𝘁 𝗳𝗿𝗲𝗲 𝘁𝗼 𝘁𝗵𝗲 𝗰𝗼𝗺𝗺𝘂𝗻𝗶𝘁𝘆.

Whether you’re working with HTTP, gRPC, GraphQL, WebSockets or even MQTT, Postman has you covered. Check it out: https://lnkd.in/gswETBCH

Principles of OOP explained.

Object-oriented programming (OOP) is a programming paradigm in which programs are designed using 𝗰𝗹𝗮𝘀𝘀𝗲𝘀 𝗮𝗻𝗱 𝗼𝗯𝗷𝗲𝗰𝘁𝘀. This design allows related functions and data to be grouped together in 𝘀𝗲𝗹𝗳-𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗱 𝗮𝗻𝗱 𝗿𝗲𝘂𝘀𝗮𝗯𝗹𝗲 𝘂𝗻𝗶𝘁𝘀.

A class is a template or blueprint from which objects are made from. Classes define the properties and methods that an object can have, and objects are unique instances of a class.

For example, let's say you want to create a life simulation game where players can adopt and raise pets. You would have a “Pet“ class that defines the properties of each pet (like “name“ and “age“), as well as behaviors they can do (like “speak“ and “eat“).

You could then create objects, or instances, of this class for each specific pet. Each object could have its own values for each property. For example, you could have a 2-year-old pet named “Winston“, & a 1-year-old pet named “Wesley“; both initialized from the “Pet“ class.

𝗢𝗯𝗷𝗲𝗰𝘁-𝗼𝗿𝗶𝗲𝗻𝘁𝗲𝗱 𝗽𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 𝗵𝗮𝘀 𝟰 𝗺𝗮𝗶𝗻 𝗽𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀; 𝗲𝗻𝗰𝗮𝗽𝘀𝘂𝗹𝗮𝘁𝗶𝗼𝗻, 𝗶𝗻𝗵𝗲𝗿𝗶𝘁𝗮𝗻𝗰𝗲, 𝗮𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻, 𝗮𝗻𝗱 𝗽𝗼𝗹𝘆𝗺𝗼𝗿𝗽𝗵𝗶𝘀𝗺.

𝗘𝗻𝗰𝗮𝗽𝘀𝘂𝗹𝗮𝘁𝗶𝗼𝗻 hides internal details but exposes data & methods via a public interface, preventing unintentional changes. E.g. — a player can view a pet's age but can't accidentally change it. But they can run methods avail on the public interface like changing a pet's name.

𝗜𝗻𝗵𝗲𝗿𝗶𝘁𝗮𝗻𝗰𝗲 allows classes to inherit properties and methods from other classes, making code reusable and organized. E.g. — A “SuperPet“ class that extends from “Pet “and would inherit “age“, “name“, “eat“, and “speak“; while defining new behaviors like “fly“

𝗣𝗼𝗹𝘆𝗺𝗼𝗿𝗽𝗵𝗶𝘀𝗺 is a principle that enables objects to change their form by extending or overriding existing methods. E.g. A “Dog“ & “Cat“ class that extended from the “Pet“, shouldn't share the same “speak“ method. You'd override it to have its own logic like “woof“ or “meow“

𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻 reduces complexity by only surfacing the information needed for a given context or use case. E.g. A “Player” class doesn’t need to know how the “eat” method works in the “Pet” class, it just needs to know how to interact with it — i.e. its input and output.

OOP provides a way to design your program that makes it 𝗿𝗲𝘂𝘀𝗮𝗯𝗹𝗲, 𝘀𝗲𝗰𝘂𝗿𝗲, 𝘀𝘁𝗮𝗯𝗹𝗲, 𝗮𝗻𝗱 𝗲𝗮𝘀𝘆 𝘁𝗼 𝘂𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱. But it isn't without disadvantages. A couple of arguments against it are that it can lead to over-engineering and complexity on a large scale.

~~

Thank you to our partner Kickresume who keeps our content free to the community.

Did you know you can turn your 𝗟𝗶𝗻𝗸𝗲𝗱𝗜𝗻 𝗶𝗻𝘁𝗼 𝗮 𝗿𝗲𝘀𝘂𝗺𝗲 𝘄𝗶𝘁𝗵 𝗼𝗻𝗲 𝗰𝗹𝗶𝗰𝗸?

Check it out: https://lnkd.in/g9ZnviCy