Khushal Patel

Somethings are better unnamed and unnoticed, Agree 😉? [Github and links in comments] Unnamed variables and unnamed patterns previewed in JDK 21 and finalized in JDK 22 [From the JEP] ✅ Captures developer intent that a given binding or lambda parameter is unused, and enforce that property, so as to clarify programs and reduce opportunities for error ✅ Improve the readability of record patterns by eliding unnecessary nested type patterns. Sunit Ghosh #Java22 #OpenJDK22 #Java #JDK #Java22 #Java21 #OpenJDK21 #Java #JDK #Java21

9

2 Comments

Scalable Application Design: Building for Growth As a software architect, designing for scalability is crucial in today's rapidly evolving tech landscape. Here's an in-depth look at key principles for creating scalable applications: 1. Modular Architecture:   - Implement microservices   - Use APIs for inter-service communication   - Ensure each module can be scaled independently   - Example: Split monolithic e-commerce app into separate services for inventory, orders, and user management 2. Stateless Design:   - Store session data in distributed caches like Redis   - Use JWT or similar tokens for authentication   - Offload state to the client when possible   - Benefit: Any server can handle any request, enabling easier horizontal scaling 3. Caching Strategies:   - Implement multi-level caching (application, distributed, CDN)   - Use read-through and write-through caching patterns   - Consider eventual consistency for non-critical data   Tools: Redis, Memcached, Varnish 4. Asynchronous Processing:   - Utilize message queues for background jobs   - Implement event-driven architectures   - Use webhooks for third-party integrations   Technologies: RabbitMQ, Apache Kafka, AWS SQS 5. Database Optimization:   - Choose appropriate DB type (relational vs NoSQL)   - Implement database sharding for horizontal scaling   - Use read replicas to offload queries   - Optimize indexes and query patterns   - Consider polyglot persistence for diverse data needs 6. Load Balancing:   - Implement layer 4 (transport) and layer 7 (application) load balancing   - Use consistent hashing for distributed caching   - Consider global load balancing for multi-region deployments   Tools: NGINX, HAProxy, cloud-native solutions (ELB, GCP Load Balancing) 7. Monitoring and Auto-scaling:   - Implement comprehensive logging and tracing   - Use time-series databases for metrics (e.g., Prometheus)   - Set up alerts for critical thresholds   - Implement predictive auto-scaling based on historical patterns   Tools: ELK stack, Grafana, Datadog 8. Content Delivery and Edge Computing:   - Utilize CDNs for static content delivery   - Implement edge computing for low-latency requirements   - Consider multi-region deployments for global user bases 9. Resilience and Fault Tolerance:   - Implement circuit breakers to prevent cascading failures   - Use retry mechanisms with exponential backoff   - Design for graceful degradation of services   Tools: Hystrix, Resilience4j 10. Performance Testing and Optimization:   - Conduct regular load testing and stress testing   - Profile your application to identify bottlenecks   - Optimize critical paths in your code   Tools: JMeter, Gatling, Locust Remember, scalability is an ongoing process. Continuously monitor, test, and refine your architecture that meets the growing demands of your users and business. Do you face any scalability challenges in your projects? #SoftwareArchitecture #ScalableDesign #TechLeadership #SystemDesign

10

1 Comment

𝗧𝗼𝗽 𝗔𝗣𝗜 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗮𝗹 𝗦𝘁𝘆𝗹𝗲𝘀 ---------------- 𝐃𝐞𝐯𝐎𝐩𝐬 𝐅𝐑𝐄𝐄 𝐖𝐞𝐛𝐢𝐧𝐚𝐫 & 𝐑𝐞𝐬𝐨𝐮𝐫𝐜𝐞𝐬 https://lnkd.in/gZHFXeTQ ---------------- Understanding different API architectural styles is important for building APIs that are strong and scalable. The style you choose can affect how you design your API and its success. Here are some common API styles: 1. 𝐑𝐄𝐒𝐓𝐟𝐮𝐥 (𝐑𝐄𝐩𝐫𝐞𝐬𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧𝐚𝐥 𝐒𝐭𝐚𝐭𝐞 𝐓𝐫𝐚𝐧𝐬𝐟𝐞𝐫): These APIs use standard HTTP methods like GET, POST, PUT, and DELETE to work with data. They're great for web apps and are known for being simple and easy to use. 2. 𝐒𝐎𝐀𝐏 (𝐒𝐢𝐦𝐩𝐥𝐞 𝐎𝐛𝐣𝐞𝐜𝐭 𝐀𝐜𝐜𝐞𝐬𝐬 𝐏𝐫𝐨𝐭𝐨𝐜𝐨𝐥): SOAP APIs use XML for data exchange and focus on security. They're good for handling transactions and secure communication. 3. 𝐖𝐞𝐛𝐒𝐨𝐜𝐤𝐞𝐭𝐬: WebSockets allow real-time communication between clients and servers. They're perfect for apps needing constant data exchange, like chats or collaborative tools. 4. 𝐆𝐫𝐚𝐩𝐡𝐐𝐋: GraphQL APIs let clients request only the data they need, making data transfer more efficient. They're flexible and great for apps with varied data needs. 5. 𝐠𝐑𝐏𝐂: gRPC is a fast RPC (Remote Procedure Call) framework. It uses Protocol Buffers for data transfer, making it efficient for communication between services. 6. 𝐌𝐐𝐓𝐓 (𝐌𝐞𝐬𝐬𝐚𝐠𝐞 𝐐𝐮𝐞𝐮𝐞 𝐓𝐞𝐥𝐞𝐦𝐞𝐭𝐫𝐲 𝐓𝐫𝐚𝐧𝐬𝐩𝐨𝐫𝐭): MQTT is a lightweight messaging protocol for low-bandwidth environments. It's used in IoT applications to connect devices with limited resources. Choosing the right API style depends on what you need. Think about what your API will do, what data it will handle, and how many clients you expect to use it. That'll help you pick the best style for your project. Follow Omkar S. for more content. Post Credit -: Omkar S. #api #softwareengineering #engineering

46

3 Comments

𝗔𝗹𝘁𝗵𝗼𝘂𝗴𝗵 𝘄𝗲’𝗿𝗲 𝘂𝘀𝗲𝗱 𝘁𝗼 𝗺𝗲𝗮𝘀𝘂𝗿𝗶𝗻𝗴 𝗰𝗼𝗵𝗲𝘀𝗶𝗼𝗻 𝗼𝗻 𝗮 𝗰𝗹𝗮𝘀𝘀 𝗹𝗲𝘃𝗲𝗹 𝗶𝘁’𝘀 𝗮 𝘄𝗶𝗱𝗲𝗿 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝗯𝗹𝗲 𝗰𝗼𝗻𝗰𝗲𝗽𝘁. A single cohesive class provides a single responsibility. But you need a composition of classes to provider a higher order responsibility which essentially also fits the definition of a module. Good architecture groups those closely collaborating classes together. If that is not the case and classes are grouped by category such as controllers this is defined as 𝙡𝙤𝙜𝙞𝙘𝙖𝙡 𝙘𝙤𝙝𝙚𝙨𝙞𝙤𝙣, which is essentially one of the poorer forms of cohesion. 𝙇𝙤𝙜𝙞𝙘𝙖𝙡 𝙘𝙤𝙝𝙚𝙨𝙞𝙤𝙣 is the antithesis of the screaming architecture. See this explained in a post by Milan Jovanović I link in the comments. Now you could repeat this reasoning for subsystems or even systems. There is even assembly metric in NDepend called Relational Cohesion that can help you with that. It’s not available on namespace/module level though. Check out the in depth video on cohesion here: https://lnkd.in/ghjQyD8i 🔔 Follow me for more analysis content & video’s. 📩 DM me if you want an in depth analysis of a codebase.

9

1 Comment

APIs are the building blocks of modern web applications, enabling seamless data exchange and functionality integration. But for the uninitiated professionals, they can seem complex. Let's break down the key concepts: Imagine your app needs nectar (data) to make honey (function). The API architecture is the communication style your bees use to collect nectar from the flowers. Here are eight popular options: 𝗔𝗣𝗜 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗦𝘁𝘆𝗹𝗲𝘀: • 𝗥𝗘𝗦𝗧 (𝗥𝗘𝗽𝗿𝗲𝘀𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻𝗮𝗹 𝗦𝘁𝗮𝘁𝗲 𝗧𝗿𝗮𝗻𝘀𝗳𝗲𝗿): The most popular, REST is lightweight and flexible. It leverages HTTP methods (GET, POST, PUT, DELETE) and URLs to manage resources. (Think clear and concise communication between applications) • 𝗦𝗢𝗔𝗣 (𝗦𝗶𝗺𝗽𝗹𝗲 𝗢𝗯𝗷𝗲𝗰𝘁 𝗔𝗰𝗰𝗲𝘀𝘀 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹): SOAP offers a structured approach with XML for data exchange and platform independence. However, it can be more complex and slower than REST.    • 𝗚𝗿𝗮𝗽𝗵𝗤𝗟: This modern approach allows requesting specific data in a single query, optimizing performance and reducing API calls.    • 𝗴𝗥𝗣𝗖: Designed for high-performance and low latency, gRPC utilizes Protobuf for data exchange, making it ideal for machine-to-machine communication.    • 𝗪𝗲𝗯𝗦𝗼𝗰𝗸𝗲𝘁𝘀: This architecture enables real-time, two-way communication, perfect for chat or live updates.    • 𝗪𝗲𝗯𝗵𝗼𝗼𝗸𝘀: These are notification mechanisms where the server pushes data to the client when specific events occur.    • 𝗥𝗲𝗺𝗼𝘁𝗲 𝗣𝗿𝗼𝗰𝗲𝗱𝘂𝗿𝗲 𝗖𝗮𝗹𝗹 (𝗥𝗣𝗖): RPC allows invoking functions on a remote server as if they were local.    • 𝗠𝗲𝘀𝘀𝗮𝗴𝗲 𝗤𝘂𝗲𝘂𝗲𝗶𝗻𝗴: This architecture uses a queue to decouple message sending and receiving, ensuring reliable message processing. 𝗖𝗼𝗺𝗺𝗼𝗻 𝗔𝗣𝗜 𝗠𝗲𝘁𝗵𝗼𝗱𝘀: • 𝗚𝗘𝗧: Retrieves data from a server. • 𝗣𝗢𝗦𝗧: Sends data to create a new resource on the server. • 𝗣𝗨𝗧: Updates an existing resource on the server. • 𝗣𝗔𝗧𝗖𝗛: Updates a specific part of a resource on the server. • 𝗗𝗘𝗟𝗘𝗧𝗘: Removes a resource from the server. • 𝗛𝗘𝗔𝗗: Retrieves meta information about a resource without transferring the entire data. • 𝗢𝗣𝗧𝗜𝗢𝗡𝗦: Requests information about the communication options of the server. • 𝗧𝗥𝗔𝗖𝗘: Traces the path a request takes across the network. • 𝗖𝗢𝗡𝗡𝗘𝗖𝗧: Establishes a tunnel connection between the client and the server. If you're serious about learning API in 2 weeks, then you need to start with these Free API courses - https://lnkd.in/e9SY44dg

1,080

34 Comments

After finding so strange and dangerous nuances in Spring Boot Reactor which I described in my previous post, one might think what to do... If you find the workarounds, how can you be sure there are no countless other problems in modern Spring Boot and its partners libraries? One option is to migrate - port the code to Micronaut or Quarkus. Here is the cold shower - you will have to port it all either to RxJava, which differs from what you have been used to in Reactor, or to Kotlin Coroutines which too allows to keep JVM code portions. Or, my personal choice is to make projects in Golang, where you control absolutely everything. Or, Node.js world worked perfectly as well. Golang will be even faster than GraalVM compiled Java/Kotlin. Spring Boot requires 300% code coverage with tests, and deep logfiles analysis all the time to deliver consistent results. It will not save the time. It will not save from the banking sector hackers. It requires 2 years of non-stop tests writing and bugs fixing. And after that there will be Spring framework users code bugfixing period too. Only then it will not fall into National Security risks category. Spring framework is the Banking System foundation... #springboot #backend #cloud #informationtechnology #informationsecurity #micronaut #quarkus #golang #nodejs

1

Post-5 of 100 useful posts series! 8 steps to build a killer high level system design [ I use this to answer, almost every HLD interview question] 🛴Choose Architecture and Components: - Select an appropriate architectural style (e.g., monolithic, microservices, serverless) - Divide application into basic 3-tiers(or n required tiers) ex: frontend, backend and database. 🚲Prioritise Frontend Core Components: - Start by choosing right systems for frontend: among VMs and containers. [There can be other ways to deploy frontend as well, but interviews are mostly about these 2.] designing the core components that are essential for the system's functionality. 🛵Consider Scalability and Performance: - Ask interviewer about expected user count, and accordingly add load balancers. - Factors to consider include horizontal/vertical scaling, caching strategies, and geographical locations of users[If users are spread across different regions, do a multi-region deployment]. 🏍️Setting Backend Services: - This is the core of design. So, take time to list and divide multiple functionalities of your application. - Put stateless APIs/functionalities on Lambda, and stateful on containers.[only core functionalities, do not divert interviewer by additional requirements.] - Add load balancers & setup other routing between frontend and backend. 🚗Select Data Storage Solutions: - Choose the appropriate data storage solutions based on requirements such as data volume, access patterns, & consistency requirements. - Consider options like relational databases (e.g., PostgreSQL, MySQL), NoSQL databases (e.g., MongoDB, Cassandra), in-memory caches (e.g., Redis). 🚙Line-up additional requirements: - For all listed additional requirements[which are mostly ML based]: create similar ML pipelines, with input load balancer and backend tier only. - Redirect requests coming to frontend servers for these extra functionalities, to Message Queue[best that companies use is Kafka and RabbitMQ], from where, ML pipelines can read data. 🏎️Big Data Management: - Add Hadoop & distributed database for big data & continuous data streams' management. - Connect ML pipelines & backend servers to Hadoop cluster. 🚜Setup Monitoring & CDN: - Monitoring & Alerting on different components & networking between them.[Best tools: Prometheus, Grafana, Graphite, Nagios | Slack, Pagerduty] - Setup CDN & cache data on user's device if required. - Setup DNS routing & firewalls for reachability and security. If you are a fresher, I'll also say as someone who worked both in Google and Adobe, and took +200 interviews till date, practically implement all these and with some DSA skills, you will be relevant to industry for hiring. As we seek people, who are good with understanding of what they have to implement post joining. Sorry to increase your things to learn ❤️ Practice designing this on a whiteboard for 3-4 apps with different use-cases to master this. #building_biggest_indian_developers_community

76

7 Comments

Diagrammatic representation makes it simpler to fathom…

7

Hashing is used in data structure to efficiently store and retrieve data in way that allows for quick access . how does this works ? suppose you have a array : 11, 12, 13,14,22 You will create a hash table like : 0 1 2 3 4 5  ( this are indexed this will be empty hash table initially ) - we will have a hash function , lets assume it will be H(x) = x%10 for now ( we have assumed this hash function for our understanding purpose) this is way complicated in real to avoid collisions as much as possible ( we will see what are collision later in the same article) so now , you want to store your array elements in the array , so that you can use it efficiently , for that we will start passing the array element to the hash table one by one like : H(x) = 11 %10  H(x) = 1  this will give us the index of the hash table where the following array element will be stored , like here we got H(x) = 1 , for x = 11 , so 11 will be stored in the index 1 of the hash table, hash table will now look like : 0 1 2 3 4 5   11     similarly pass next elements in the hash function , H(x) = 12%10 h(x) = 2 hash table : 0 1  2  3  4  5   11 12    3) H(x) = 13%10   H(x) = 3 hash table : 0 1   2  3  4  5   11 12 13    4) H(x) = 14%10    H(x) = 4    hash table : 0 1  2  3  4   5    11 12 13 14    Question : why retrieval of element from hashing is efficient way ?  lets take a very simple example, lets say now you want to find if 13 is present in my array or not ,In the normal case when we are not using hashing we will travel the array and find if the element is present , which will take O(n) in worst case. But , here you will the key that you want to find , eg : 13 will be passes to the same hash function eg :  H(x) = 13%10 H(x) = 3 This is will go on the 3rd index and check if it has that value , no need to check for other elements and this is a O(1) operation which is much better than O(n) ================================================= Now comes a interesting case , If you have noticed we haven't finished the traversal of complete array , 22 still remains to be passed in the hash function , so let's pass it 5) H(x) = 22%10     H(x) = 2    now according to the flow/ design of hashing , we will go to the index 2 of the hash table and try to place array element 22 there. hash table : 0 1  2   3  4   5    11 12 13 14     22   But wait there is already a element present at this index in hash table , how can we put this element ?? will this remove the old one ?? is the design/concept of hashing wrong ?? so this is known as Collision in hashing , when there is already a element present in the hash table at the same index and we want to put our element there this is known as collision. How do we move forward then ? so there are different methods to handle the collision , which we will look into different post since this one has already became much longer. Stay tuned/ connected for next interesting posts #hashing #dsa #java #hash

8

We start looking at the common protocols for Web APIs. REST (Representational State Transfer) is an architectural style which describes a set of constraints applicable on the architecture of a distributed, Internet-scale hypermedia system. It was introduced by Roy Fielding as a part of his PHD dissertation 'Architectural Styles and the Design of Network-based Software Architectures’ in 2000.   The constraints specified by REST on RESTful APIs are:- 1) Client-Server Architecture:- This architecture consists of clients which request for a resource through a request which is served by a server. The key principle behind this constraint is the separation of concerns enabling scaling independently.   2) Stateless:- Each request from the client to the server must be stateless, meaning it can’t use any stored context. This introduces the properties of visibility, reliability and scalability. There are some trade-offs with this constraint too - mainly the need to send a lot more repetitive data over the network and the need to store state on the client side.   3) Cacheable - Cache constraints added to the response. The data within a response must be labeled cacheable or not. This can reduce server load, improve performance and minimize latency. The only trade-off is if the cached data becomes stale.   4) Uniform Interface:- This is the central distinguishing feature of REST. Basically this specifies that there should be a uniform way of interacting with the server irrespective of the device of type of the client or application. It has the following guiding principles:- a) Identification of resources - eg. API/subjects b) Manipulation of resources through representations - Client has representation of resources which enables modification of resources if they have the required permissions. c) Self descriptive messages - The messages should be self explanatory. d) Hypermedia as the Engine of the Application State (HATEOAS) - Should include the links for each response so that client can discover resources easily.   5) Layered System:- Architecture consists of multiple layers and each layer can’t see beyond the layers with which it is interacting. Intermediary servers may improve system availability by enabling load-balancing and by providing shared caches.   6) Code-On-demand:- The only optional constraint. According to this servers can also provide executable code to the client to extend functionality. eg. Javascript server-side scripts. RESTful APIs are generally lightweight, format-agnostic (can use XML, JSON etc.), independent of client and server, and built to be scaleable and flexible. A postman collection of some public RESTful APIs https://lnkd.in/gwqDxgVC #webapis #fundamentals #restfulapis #RESTConstraints

11

Microservices architecture breaks down applications into smaller, independently deployable services that communicate through APIs. For a platform like LinkedIn, this approach allows for better scalability, flexibility, and maintainability. Here's a detailed overview of how microservices might work for handling LinkedIn posts: ### Key Microservices Involved in LinkedIn Post 1. **User Service**: - Manages user profiles, authentication, and authorization. - Ensures the user has the necessary permissions to create, edit, or delete posts. 2. **Post Service**: - Handles the creation, retrieval, updating, and deletion of posts. - Stores metadata related to posts such as creation date, author, and visibility settings. 3. **Content Service**: - Manages the storage and retrieval of multimedia content (images, videos) associated with posts. - Interfaces with a CDN (Content Delivery Network) for efficient media delivery. 4. **Feed Service**: - Manages the aggregation and delivery of posts to users' feeds. - Applies algorithms to personalize the feed based on user preferences and behavior. 5. **Notification Service**: - Handles the generation and delivery of notifications when a post is created, liked, or commented on. - Ensures timely updates to users regarding interactions with their posts. 6. **Analytics Service**: - Tracks and analyzes engagement metrics for posts such as views, likes, shares, and comments. - Provides insights to users and drives recommendation algorithms. 7. **Comment Service**: - Manages comments on posts, including creation, retrieval, and deletion. - Integrates with the Post Service to keep the comment count updated. 8. **Search Service**: - Indexes posts and comments to enable efficient search functionality. - Supports advanced search features like filtering by date, user, or post type. ### Workflow of Creating a Post 1. **Authentication**: - The User Service verifies the identity and permissions of the user. 2. **Post Creation**: - The user sends a request to the Post Service to create a new post. - The Post Service validates the request, processes the content (text and multimedia), and saves the post metadata. 3. **Content Storage**: - If the post includes multimedia, the Content Service stores the files and generates URLs for accessing the media. 4. **Feed Update**: - The Feed Service updates the user’s feed and potentially the feeds of their connections to include the new post. 5. **Notification**: - The Notification Service sends alerts to the user's connections, informing them of the new post. 6. **Indexing**: - The Search Service indexes the new post to make 7. **Analytics Tracking**: - The Analytics Service begins tracking interactions with the post for engagement metrics. ### Communication and Coordination - **API Gateway**: - Acts as an entry point for all client requests, routing them to the appropriate microservice.

2

Jenkins is defined as an open-source solution comprising an automation server to enable continuous integration and continuous delivery (CI/CD), automating the various stages of software development such as test, build, and deployment. This article explains how Jenkins works, its key features and use cases, and the functionality of a Jenkins pipeline. Jenkins software’s popularity stems from its ability to track and monitor repetitive activities that emerge throughout a project’s development. For example, if your team is working on a project, Jenkins will continually test your builds and alert you to any mistakes early in the process. Its top use cases include: 1. Deploying code into production 2. Enabling task automation 3. Reducing the time it takes to review a code 4. Driving continuous integration 5. Increasing code coverage 6. Enhancing coding efficiency  7. Simplifying audits 8. Using Slack for synchronisation Enroll here for PRIME7.0 BATCH exclusive for DevOps/SRE engineers https://bit.ly/primebatch7 [ Actual Classes are starting from today ] Checkout my youtube channel https://lnkd.in/gptB-jmR Connect with me on Instagram https://lnkd.in/dW6GJMiS

465

22 Comments

𝐖𝐡𝐚𝐭 𝐚𝐫𝐞 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐚𝐥 𝐓𝐨𝐩 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬? Architectural patterns are standard strategies that define structural organization for software systems, providing a template for the architecture's design and module interactions. Here are famous architectural patterns: ➡ 1. 𝐄𝐯𝐞𝐧𝐭-𝐃𝐫𝐢𝐯𝐞𝐧: An event-driven architecture is a framework that orchestrates behavior around the production, detection, and consumption of events. Example use case: A real-time analytics system where events are generated by user activities and processed immediately. ➡ 2. 𝐋𝐚𝐲𝐞𝐫𝐞𝐝: A layered architecture is a hierarchical pattern for structuring a system into groups of related functionalities, each layer having a specific role. Example use case: A web application with a presentation layer, business logic layer, and data access layer. ➡ 3. 𝐌𝐨𝐧𝐨𝐥𝐢𝐭𝐡: A monolithic architecture is a traditional unified model for the design of a software program where all components are interwoven and interdependent. Example use case: A small-scale e-commerce website where the user interface, server-side application, and database are all on a single platform. ➡ 4. 𝐌𝐢𝐜𝐫𝐨𝐬𝐞𝐫𝐯𝐢𝐜𝐞: Microservices architecture is an approach where a single application is composed of many loosely coupled and independently deployable smaller services. Example: A large-scale cloud-based application like Netflix, where each service runs a unique process and communicates through a well-defined, lightweight mechanism to serve a business goal. ➡ 5. 𝐏𝐢𝐩𝐞-𝐅𝐢𝐥𝐭𝐞𝐫: In pipe-filter architecture data passes through a sequence of components (filters) each designed to process the data in some way. The movement of data through the filters is handled by connectors (pipes) that do not change the data but pass it from one filter to another. ➡ 6. 𝐏𝐞𝐞𝐫-𝐭𝐨-𝐏𝐞𝐞𝐫: P2P architecture is a decentralized network architecture where each node, or "peer," acts as both a client and a server. Peers are equally privileged and can initiate or complete tasks such as data sharing or communication directly with each other without relying on a central server. ➡ 7. 𝐌𝐕𝐂 (𝐌𝐨𝐝𝐞𝐥-𝐕𝐢𝐞𝐰-𝐂𝐨𝐧𝐭𝐫𝐨𝐥𝐥𝐞𝐫): MVC separates an application into three interconnected components: the model, the view, and the controller. Example: A desktop GUI application where user interface data (view), data manipulation (model), and input control (controller) are separated to simplify maintenance and scalability. ➡ 8. 𝐏𝐫𝐢𝐦𝐚𝐫𝐲-𝐑𝐞𝐩𝐥𝐢𝐜𝐚 (or Primary-Secondary): The primary-replica pattern is a model where one primary component controls one or more subordinate instances, called replicas. Example use case: A database replication system where the primary database manages writes and the replica databases handle read operations to distribute the load. 🔴 System Design Interview Roadmap - https://lnkd.in/gQzGm8Yb 🔴 Join my free newsletter on system design: https://lnkd.in/gpHAFd9t

642

5 Comments

A very useful detailed blog by Georgios - Nikolaos Palaiologopoulos which explains spring caches with code samples on demo MVC application. A good refresher on application data caching! https://lnkd.in/gy8AxV8D #spring #caches

17

What is GraphQL? Is it a replacement for the REST API? GraphQL is a query language for APIs and a runtime for executing those queries by using a type system you define for your data. It was developed internally by Meta in 2012 before being publicly released in 2015. Unlike the more traditional REST API, GraphQL allows clients to request exactly the data they need, making it possible to fetch data from multiple sources with a single query. This efficiency in data retrieval can lead to improved performance for web and mobile applications. GraphQL servers sit in between the client and the backend services. It can aggregate multiple REST requests into one query. GraphQL server organizes the resources in a graph. GraphQL supports queries, mutations (applying data modifications to resources), and subscriptions (receiving notifications on schema modifications). Benefits of GraphQL: GraphQL is more efficient in data fetching. GraphQL returns more accurate results. GraphQL has a strong type system to manage the structure of entities, reducing errors. GraphQL is suitable for managing complex microservices. Disadvantages of GraphQL Increased complexity. Over fetching by design Caching complexity blog.bytebytego.com Want to know more? Follow me or connect🥂 Please don't forget to like❤️ and comment💭 and repost♻️, thank you🌹🙏 #backend #fullStack #developer #Csharp #github #EFCore #dotnet #dotnetCore #programmer #azure #visualstudio

171

46 Comments

🌀 Saga Design Pattern: Ensuring Data Consistency in Microservices The Saga design pattern is a crucial architectural pattern for maintaining data consistency in distributed microservices environments. It handles long-lived transactions by breaking them into a series of smaller, isolated transactions that can be managed independently. **What is the Saga Pattern?** - **Distributed Transactions:** Manages transactions across multiple microservices without locking resources. - **Choreography-Based:** Each service produces and listens to events, and events trigger the next local transaction. - **Orchestration-Based:** A central coordinator directs each step of the transaction by invoking microservices. #### **Key Benefits:** 1. **Data Consistency:**   - Ensures data consistency across services without the need for a central transaction coordinator. 2. **Scalability:**   - Enhances system scalability by avoiding long-held locks on resources. 3. **Resilience:**   - Improves system resilience by enabling compensation actions (rollback) when a transaction step fails. 4. **Flexibility:** �� - Adapts to complex business processes by supporting both choreography and orchestration. #### **How It Works:** 1. **Initiation:**   - A business process starts the saga by initiating the first transaction. 2. **Execution:**   - Each transaction updates a single service and publishes an event. 3. **Event Listening:**   - The subsequent service listens to the event and performs its transaction. 4. **Compensation:**   - If a transaction fails, compensating transactions are executed to undo previous steps. #### **Example Scenario:** 1. **Order Service:**   - Creates an order and emits an event. 2. **Payment Service:**   - Processes payment upon receiving the order event. 3. **Inventory Service:**   - Updates inventory after payment success. 4. **Shipping Service:**   - Ships the product upon inventory update. #### **When to Use the Saga Pattern:** - **Microservices Architecture:**   - Ideal for systems with microservices that need to maintain consistency without a central database. - **Complex Transactions:**   - Suitable for workflows involving multiple steps that can be independently managed. - **High Availability Systems:**   - Essential for systems requiring high availability and resilience to partial failures. By implementing the Saga design pattern, you can manage distributed transactions effectively, ensuring your microservices architecture remains robust, consistent, and scalable. 🌟 #SagaPattern #Microservices #DistributedSystems #DataConsistency #ScalableArchitecture #ResilientSystems #SoftwareArchitecture #TechInnovation

4

🚀 Got insights on Map-Reduce with completion of "Distributed Processing Fundamentals" module offered by TrendyTech 👇 Summary of Key Learnings 👇 🔶 Map Reduce is a distributed computing framework to process big data, Consists of 2 Phases : Both takes input in (K,V) Pair- 1. Mapper Phase - Gives Parallelism. 2. Reducer Phase - For Aggregating the Results from Mapper. Always try to shift computation from Reducers end to Mappers end more. Maximum work done in Mapper end would lead to more parallelism & less data shuffled, ultimately leading to good performance. By default we have 1 reducer. We can increase no's of reducers when we are not able to optimize more work at mapper end & that task can only be done by reducer. In some cases, we will not require aggregation of results & mapper output is the final output. So we can even modify no's of reducer to 0. 🔸 Partitions - It comes into picture when we have more than 1 reducer. it decides how the data has to be presented to the reducer and also assigns it to a particular reducer. By default we have a system defined consistent 'Hash Function' to tell which (K,V) pair to goes to which reducer. 🔸 Shuffle - Output from the Mapper is sent to Reducer for further processing/aggregation known as Shuffle. 🔸 Sort - Its an operation done on reducer machine to get the same keys together in a group. So values with same keys appear as collection to the reducer. 🔸 Combiner - Its used to achieve local aggregation at mappers end & reduce data transfer to reducer. After the initial processing at mapper, local aggregation takes place at mapper end for better performance. Then the data is partitioned (if multiple reducers) and shuffled to reducers where it is sorted before final aggregation. 🔸 So, A Map Reduce Job flow is as follows - Mapper >> Combiner >> Partitioner >> Shuffle >> Sort >> Reducer. 🔶 Challenges with Map Reduce : -- Performance is quite slow as it has lot of Disk IO's. for Ex. 9 Map Reduce Jobs will have 18 disk IO (9 for read & 9 for write). -- Need to write multiple lines of codes even for a simpler logical job. -- Supports only batch processing & not suitable for Real time processing/streaming. -- Learning curve is quite high compared to its other alternatives. -- Every problem needs to be think in a map-reduce perspective. Thanks Sumit Mittal Sir & TrendyTech team !! #Bigdata #dataengineering #Azuredataengineer #Mapreduce #Learning #Upskill

9

5 commonly asked design pattern questions in a front-end interview ! 1. Singleton Pattern   Que: Can you explain the Singleton pattern and give an example of where it might be used in front-end development?   Ans: Imagine you have a global news broadcasting system. There can only be one central broadcasting station sending out signals to everyone. In your code, the Singleton pattern ensures there's only one instance of a class, like this broadcasting station. This is useful for things like managing the state of an application where you want a single, consistent source of truth. 2. Observer Pattern   Que: What is the Observer pattern and how is it used in front-end frameworks like React?   Ans: Think of a news subscription service. When you subscribe to a newspaper, you receive updates whenever a new edition is published. The Observer pattern works similarly in front-end development. Components (subscribers) watch for changes in the state (newspapers), and when the state updates, the components are automatically informed and updated. In React, this is like how state changes cause re-renders. 3. Factory Pattern   Que: Can you explain the Factory pattern and provide a use case for it in JavaScript?   Ans: Imagine a car factory where you can specify the type of car you want, and the factory produces it for you. The Factory pattern in code works the same way: you have a function or method that creates objects for you, depending on the input parameters. This is useful in front-end development for creating various UI components dynamically based on user interaction. 4. Decorator Pattern   Question: What is the Decorator pattern and how can it be useful in extending functionality of objects in JavaScript?   Ans: Think of a plain coffee that you can customize by adding different toppings like whipped cream or syrup. The Decorator pattern allows you to start with a basic object (plain coffee) and add new functionalities (toppings) without modifying the original object. In JavaScript, you might use this to enhance a function with additional features, such as adding logging or validation. 5. Module Pattern   Que: Can you describe the Module pattern and how it helps in organizing JavaScript code?   Ans: Imagine your kitchen where you have different cabinets for spices, utensils, and dishes. Each cabinet organizes items in a way that keeps things neat and accessible. The Module pattern in JavaScript is like these cabinets; it helps you encapsulate code into neat, organized units, each with its own scope. This makes your code more modular, maintainable, and prevents naming collisions.     For more insightful content checkout below: 🟦 𝑳𝒊𝒏𝒌𝒆𝒅𝑰𝒏 - https://lnkd.in/dwi3tV83 ⬛ 𝑮𝒊𝒕𝑯𝒖𝒃 - https://lnkd.in/dkW958Tj 🟥 𝒀𝒐𝒖𝑻𝒖𝒃𝒆 - https://lnkd.in/dDig2j75 or Priya Frontend Vlogz 🔷 𝐓𝐰𝐢𝐭𝐭𝐞𝐫 - https://lnkd.in/dyfEuJNt #frontend #javascript #react #reactjs #html #css #typescript #es6 #interviewquestions #interview #interviewpreparation

141

16 Comments

𝗧𝗼𝗽 𝟴 𝗧𝘆𝗽𝗲𝘀 𝗼𝗳 𝗔𝗣𝗜 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗦𝘁𝘆𝗹𝗲𝘀 Understanding the different API architecture styles is essential for building robust and scalable applications. In this post, we'll explore the top 8 types of API architecture styles: • 𝗦𝗢𝗔𝗣 (𝗦𝗶𝗺𝗽𝗹𝗲 𝗢𝗯𝗷𝗲𝗰𝘁 𝗔𝗰𝗰𝗲𝘀𝘀 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹): SOAP is an XML-based messaging protocol that is widely used for enterprise applications. It is a heavyweight protocol that can be complex to set up and use. • 𝗥𝗘𝗦𝗧 (𝗥𝗲𝗽𝗿𝗲𝘀𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻𝗮𝗹 𝗦𝘁𝗮𝘁𝗲 𝗧𝗿𝗮𝗻𝘀𝗳𝗲𝗿): REST is a lightweight architecture style that is based on HTTP and standard HTTP methods (GET, POST, PUT, DELETE). REST is the most popular API architecture style today because it is simple to understand and implement. • 𝗚𝗿𝗮𝗽𝗵𝗤𝗟: GraphQL is a query language for APIs that allows clients to request specific data. This can improve the performance of your API by reducing the amount of data that is transferred between the client and the server. • 𝗴𝗥𝗣𝗖: gRPC is a high-performance framework for remote procedure calls (RPCs). It uses HTTP/2 for transport and Protocol Buffers for data serialization. gRPC is a good choice for microservices architectures where performance is critical. • 𝗪𝗲𝗯𝗦𝗼𝗰𝗸𝗲𝘁: WebSockets are a real-time communication protocol that allows for bi-directional communication between clients and servers. WebSockets are a good choice for applications that need to update data in real-time, such as chat applications and live streaming. • 𝗪𝗲𝗯𝗵𝗼𝗼𝗸: Webhooks are a event-driven mechanism that allows a server to send notifications to other applications when certain events occur. Webhooks are a good choice for applications that need to react to changes in real-time, such as CI/CD pipelines and social media monitoring. • 𝗠𝗤𝗧𝗧 (𝗠𝗲𝘀𝘀𝗮𝗴𝗲 𝗤𝘂𝗲𝘂𝗶𝗻𝗴 𝗧𝗲𝗹𝗲𝗺𝗲𝘁𝗿𝘆 𝗧𝗿𝗮𝗻𝘀𝗽𝗼𝗿𝘁): MQTT is a lightweight messaging protocol that is designed for constrained devices and low-bandwidth networks. MQTT is a good choice for Internet of Things (IoT) applications. • 𝗔𝗠𝗤𝗣 (𝗔𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝗠𝗲𝘀𝘀𝗮𝗴𝗲 𝗤𝘂𝗲𝘂𝗶𝗻𝗴 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹): AMQP is a robust messaging protocol that is designed for reliable communication between applications. AMQP is a good choice for enterprise applications that require high levels of reliability and security. Choosing the right API architecture style for your project depends on a number of factors, such as the performance requirements, scalability requirements, and the type of data that will be exchanged between the API and the client. I hope this post has been helpful! #API #architecture #softwareengineering  #microservices

1,468

30 Comments