yolanda edward

blessed beyond measure✨ E💛 よろしくね！：）

[Bytebytego @bytebytego]

CI/CD Pipeline Explained in Simple Terms

Section 1 - SDLC with CI/CD
The software development life cycle (SDLC) consists of several key stages: development, testing, deployment, and maintenance. CI/CD automates and integrates these stages to enable faster, more reliable releases.
When code is pushed to a git repository, it triggers an automated build and test process. End-to-end (e2e) test cases are run to validate the code. If tests pass, the code can be automatically deployed to staging/production. If issues are found, the code is sent back to development for bug fixing. This automation provides fast feedback to developers and reduces risk of bugs in production.

Section 2 - Difference between CI and CD
Continuous Integration (CI) automates the build, test, and merge process. It runs tests whenever code is committed to detect integration issues early. This encourages frequent code commits and rapid feedback.

Continuous Delivery (CD) automates release processes like infrastructure changes and deployment. It ensures software can be released reliably at any time through automated workflows. CD may also automate the manual testing and approval steps required before production deployment.

Section 3 - CI/CD Pipeline
A typical CI/CD pipeline has several connected stages:
- Developer commits code changes to source control
- CI server detects changes and triggers build
- Code is compiled, tested (unit, integration tests)
- Test results reported to developer
- On success, artifacts are deployed to staging environments
- Further testing may be done on staging before release
- CD system deploys approved changes to production

--
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://t.co/FIzCeaWsZV

[Abraham John 🦄🦓 @Abmankendrick]

UI/UX Designers and Developers, here are web breakpoint cheat sheets for all devices that can help with your website's layout for your next UI design project.

Bookmark it for later 💜

[Alex Xu @alexxubyte]

How does Docker Work?

[Dr Milan Milanović @milan_milanovic]

𝗔𝗣𝗜 𝗚𝗮𝘁𝗲𝘄𝗮𝘆 𝘃𝘀 𝗟𝗼𝗮𝗱 𝗕𝗮𝗹𝗮𝗻𝗰𝗲𝗿 𝘃𝘀 𝗥𝗲𝘃𝗲𝗿𝘀𝗲 𝗣𝗿𝗼𝘅𝘆

Regarding a system design, we often need clarification about the roles of a Load Balancer and an API Gateway. Most of our resources are about their implementation rather than real-life use cases.

🔹 𝗔𝗣𝗜 𝗚𝗮𝘁𝗲𝘄𝗮𝘆 sits between a client and a group of backend services. It performs the function of a reverse proxy by accepting all application programming interface (API) calls, aggregating the different services needed to fulfill them, and returning the right outcome. 𝗨𝘀𝗲𝗿 𝗮𝘂𝘁𝗵𝗲𝗻𝘁𝗶𝗰𝗮𝘁𝗶𝗼𝗻, 𝗿𝗮𝘁𝗲 𝗹𝗶𝗺𝗶𝘁𝘀, 𝗮𝗻𝗱 𝘀𝘁𝗮𝘁𝗶𝘀𝘁𝗶𝗰𝘀 are typical duties that API gateways take care of on behalf of a system of API services. Also, the API gateway can handle faults (circuit breaker) and log and monitor.

🔹 𝗟𝗼𝗮𝗱 𝗕𝗮𝗹𝗮𝗻𝗰𝗲𝗿 is a service that distributes incoming traffic across many servers or resources. Usually, we have two or more web servers on the backend, and it 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝘀 𝗻𝗲𝘁𝘄𝗼𝗿𝗸 𝘁𝗿𝗮𝗳𝗳𝗶𝗰 𝗯𝗲𝘁𝘄𝗲𝗲𝗻 𝘁𝗵𝗲𝗺. Its primary purpose is to use resources optimally. A more equal task allocation and increased capacity can enhance the system's responsiveness and reliability. There are three high-level load balancers: hardware-based, cloud-based, and software-based.

🔹 𝗥𝗲𝘃𝗲𝗿𝘀𝗲 𝗣𝗿𝗼𝘅𝘆 server resides in front of backend servers and transfers client requests to these servers. Reverse proxies are typically used to increase security, speed, and dependability. A reverse proxy receives a request from a client, forwards it to another server, and then returns it to the client, giving the impression that the first proxy server handled the request. These proxies ensure that users don't access the origin server directly, giving the web server anonymity. They are usually used for Load balancing, where we need to deal with incoming traffic flow so that we may distribute that traffic between multiple backend servers or use them for caching.

So, the main thing that differs these two is that an 𝗔𝗣𝗜 𝗚𝗮𝘁𝗲𝘄𝗮𝘆 𝗶𝘀 𝗳𝗼𝗰𝘂𝘀𝗲𝗱 𝗼𝗻 𝗿𝗼𝘂𝘁𝗶𝗻𝗴 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 to the appropriate service and it handles requests for APIs, while a 𝗟𝗼𝗮𝗱 𝗯𝗮𝗹𝗮𝗻𝗰𝗲𝗿 𝗶𝘀 𝗳𝗼𝗰𝘂𝘀𝗲𝗱 𝗼𝗻 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗶𝗻𝗴 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 𝗲𝘃𝗲𝗻𝗹𝘆 between a group of servers and handles requests that are sent to a single IP address, which works at protocol or socket level (TCP, HTTP).

Some 𝗲𝘅𝗮𝗺𝗽𝗹𝗲𝘀 of API Gateways are Amazon API Gateway, Ocelot (.NET-based), Tyk, or Apache APISIX, while Load Balancers are Azure Load Balancer, HAProxy, or Seesaw.

An example of reverse proxy services is 𝗔𝗽𝗮𝗰𝗵𝗲 𝗣𝗿𝗼𝘅𝘆, 𝗡𝗴𝗶𝗻𝘅 𝗼𝗿 𝗜𝗜𝗦 with additional modules (Url Rewrite).

#programming #api

[Nikki Siapno @NikkiSiapno]

How do we design effective and safe APIs?

APIs have increasingly become the backbone of modern software.

To understand some of the key principles and best practices of API design, Let's analyze a social media platform example:

🔹 Resource naming

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.

🔹 Use of plurals

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.

🔹 Cross-referencing resources

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.

🔹 Security

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.

Learn more about API security here: https://t.co/AEZgiZNmxt

🔹 Versioning

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.

Learn more about API versioning here: https://t.co/FQsJ3jcIsl

🔹 Pagination

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.

🔹 Idempotency

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.

These practices are very important, but there’s still much more to API design.

Learn more about API design here: https://t.co/fiaya7akdA

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.

[Inferam @InferamAI]

Imagine telling this story without proof:

“I didn't go to work because a cat fell on my head and then a dog with shoes tried to do me justice.”

[yolanda edward @nandayolanda]

Marriage is not scary if you found the right one. Marriage is hard but love and affection between you and your spouse conquer it all. There is no perfect marriage, we are all scattered. But by those things we experienced, we grow a life that we can not live without each other.🤍

[yolanda edward @nandayolanda]

Nonton deadpool wolverine, suamik fokus nonton dari awal sampe akhir, gw sibuk ngunyah fish&chips, pop corn ama nyemilin keju ampe bersih. Pas makanan abis, gangguin suamik yg lg fokus nonton+gelendotan aja nyari kerjaan😅 untung suamik penyabarrr bgt orgnya🙃🤝 @edwardtoruan

[Nikki Siapno @NikkiSiapno]

Object-Oriented Programming in Under 4 Minutes:

Object-oriented programming (OOP) is a programming paradigm in which programs are designed using classes and objects. This design allows related functions and data to be grouped together in self-contained and reusable units.

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.

Object-oriented programming has 4 main principles; encapsulation, inheritance, abstraction, and polymorphism.

Encapsulation 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.

Inheritance 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"

Polymorphism 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"

Abstraction 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 reusable, secure, stable, and easy to understand. 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 LinkedIn into a resume with one click?

Check it out: https://t.co/DIeENAT5gp

[Words @itswords_]

life update:

[Maniesh.Neupane @pwn4arn]

Bypassing Rate Limit Protection

[yolanda edward @nandayolanda]

Si kalem dan si pecicilan (aku yang kalem😌) @edwardtoruan

[Nikki Siapno @NikkiSiapno]

This week I will cover:

— Strategies to prevent system misuse & overload
— Types of API testing
— How the TCP handshake works
— Containerization explained
— Principles of OOP

📩 Enjoy my content? Subscribe to my weekly newsletter so you don't miss it: https://t.co/nLXHushrhP

[yolanda edward @nandayolanda]

Thank you React Native. I am so thankful I have you as my language now🥲

[yolanda edward @nandayolanda]

That awkwardness of changing from console.log to dd again🙃

[yolanda edward @nandayolanda]

@Little_secret9 Sakit jiwaaa!!!!!! Aslik klo berita2 ttg anak2 kaya gini ke trigger parah gw😭😭😭😭😭 rot in hell you freak pedo!!!!!!!! Rrrgghhhhh

[Nikki Siapno @NikkiSiapno]

This week we will cover:

— Understanding the components of system design
— GraphQL vs REST
— How DDoS attacks work, and how to prevent them
— SSL vs TLS

Don’t want to miss out? Subscribe to our free newsletter for a weekly deep dive & content roundup: https://t.co/o8ShggS5mk

[Chris Staudinger @ChrisStaud]

Webhook vs Polling — What's the difference?

Imagine we run a project management platform. As users make changes to tasks, the challenge lies in ensuring these changes are reflected on every user's interface in that team.

There are two ways to handle communications to achieve these synchronized updates across all user interfaces - Polling and Webhooks.

𝗔𝗣𝗜 𝗣𝗼𝗹𝗹𝗶𝗻𝗴 is a 𝗽𝘂𝗹𝗹-𝗯𝗮𝘀𝗲𝗱 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 operating on a "check-in" system. The client regularly makes API calls to the server to check for any changes to any tasks. To address the challenge of updating all user interfaces, polling would have the system routinely execute these API requests for changes, ensuring that, even though updates may not be instantaneous, they are still consistently captured and communicated to all users in due course.

In contrast, using a 𝘄𝗲𝗯𝗵𝗼𝗼𝗸 would 𝘀𝗲𝗻𝗱 𝗮 𝗻𝗼𝘁𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻 to the system 𝗼𝗻𝗹𝘆 𝘄𝗵𝗲𝗻 there is 𝗻𝗲𝘄 𝗱𝗮𝘁𝗮 𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗹𝗲. Webhooks adopt a 𝗽𝘂𝘀𝗵-𝗯𝗮𝘀𝗲𝗱 𝗺𝗲𝘁𝗵𝗼𝗱𝗼𝗹𝗼𝗴𝘆. This setup entails the server taking the initiative to send notifications. When a task undergoes any modification, it triggers an immediate alert from the server, which dispatches information directly to the project management platform's 𝗽𝗿𝗲𝗱𝗲𝗳𝗶𝗻𝗲𝗱 𝘄𝗲𝗯𝗵𝗼𝗼𝗸 𝗨𝗥𝗟. This payload contains the details of the updated task. Once the platform has received the data, it reflects the changes across all user interfaces.

In our scenario, using polling would mean our application would waste resources continuously querying the server, & communicating tasks updates would be delayed. Using a webhook, on the other hand, ensures that as soon as a task is updated, everyone receives the update, as well as no resource wastage.

Deciding between polling and webhook depends on your needs.

Choose Polling for:

🔸 Scenarios where simplicity and ease of implementation are more important than immediate data delivery
🔸 Preference for controlled, periodic update checks
🔸 Integrating with older systems that do not support webhook capabilities

Opt for Webhooks when:

🔸 Your application needs to be notified as soon as new data is available.
🔸 You need to minimize the frequency of your API calls.
🔸 You’re looking to decouple systems for better scalability
🔸 Your system needs to receive updates from a data source that is frequently updated.

Webhooks provide a more efficient and real-time solution, enabling immediate data synchronization as opposed to the delayed response of polling. However, they do come with the trade-off of increased complexity in setup and maintenance.

~~~

A big thank you to our partner Postman who keeps our content free to the community.

Postman have made it possible to test your API without leaving your code editor thanks to Postman’s VS Code extension.

Check it out: https://t.co/kDllh8s6yr

📩 If you found this helpful, consider subscribing to our newsletter where we help you level up your engineering and system design skills: https://t.co/076cpzUaQo

[yolanda edward @nandayolanda]

@LSTRmegaputri Seru yang. Mo mati sih rasa nya cm pas udh selesainya undescribable feeling lah wkwkwk yuk yuk kita lari gol🥰

[yolanda edward @nandayolanda]

Chat WA sekarang full dengan bahasan sepatu lari dan event lari @edwardtoruan tenang tiga bulan lagi jd athlet lari dah siap bgt ikut marathon 42km🙏🏻