Govindaraj Munuswamy

*Code reviews* Architect to Developer - Implement all HTTP response/error codes. Should not take more than 1 hour 🙂 Developer - Check this and let me know 👇 Architect - After some silence, I think you should make your own judgement and give your estimate 🧐 Developer - Sure 🤠 Architect to himself - Narrow escape 😁 Lesson - If I want to guide the team, I should stay hands-on with coding or refer right documentation. #developer #coding #codereview #api #http #softwaredev #softwarearchitect #techdiscussion #apidevelopment

18

I recently had the pleasure of diving into “Web API Development with ASP.NET Core 8” by Xiaodi Yan, a comprehensive guide that expertly covers techniques, patterns, and tools for building high-performance, robust, and scalable web APIs. This book is a good read for any developer looking to master ASP.NET Core 8. Xiaodi Yan does an exceptional job of breaking down complex concepts into digestible sections, making it accessible for both beginners and experienced developers. The book's practical approach, with plenty of examples and exercises, helps solidify understanding and build confidence in applying these techniques to real-world projects. One of the standout features of the book is its focus on performance and scalability. In today’s fast-paced tech environment, building APIs that can handle high loads efficiently is crucial, and this book provides the insights needed to achieve that. From advanced configuration settings to optimized data handling and security best practices, it covers all the essential aspects to ensure your web APIs are not just functional but also robust and future-proof. With 800+ pages this book covers essential techniques, patterns, and tools for building high-performance, robust, and scalable web APIs. The book includes fundamental concepts to advanced and latest topics like .Net Aspire and additionally: • An overview of web APIs and styles (REST, gRPC, GraphQL, real-time) • ASP.NET Core essentials like project setup, routing, and middleware • In-depth data access with Entity Framework Core • Security with ASP.NET Core Identity • Comprehensive testing strategies • Advanced API types and CI/CD processes • Best practices for error handling, monitoring, and cloud-native patterns I would like to extend my gratitude to @Packt and the amazing staff member Nivedita P. who introduced me to this valuable resource. For anyone involved in web API development, or those looking to start, this book is a valuable addition to your library. Grab your copy - https://lnkd.in/eTUMV38E #WebDevelopment #ASPNetCore #API #BookReview #PacktPublishing #ProfessionalGrowth #SoftwareDevelopment

23

Check out this hilariously insightful article on why HTMX "sucks" – spoiler: it doesn't! 🦄✨ While some argue that its single-file JavaScript and lack of build tools make it a relic, others see HTMX as a breath of fresh air. Forget overcomplicated setups; HTMX brings back the simplicity and power of HTML. If you're tired of JavaScript fatigue and just want things to work, HTMX might be your new best friend. Don't take my word for it, though; read the full article and decide for yourself: https://lnkd.in/e3FwGPv5 #WebDevelopment #JavaScript #HTMX #HTML #FrontendRevolution #CodingHumor

10

🚀 Scaling Microservices: A Visual Guide 🌐 In today’s fast-paced digital world, scaling microservices efficiently is crucial for robust application performance. Here’s a quick visual breakdown of how microservices architecture can be scaled: 1. User Interaction: Users interact via web or mobile apps. 2. API Gateway: Central hub managing all API requests. 3. Load Balancer: Distributes network or application traffic across multiple servers. 4. Microservices : Independent services (e.g., Service A, Service B) handling specific business functions. 5. Databases: Utilizing both SQL and NoSQL databases (e.g., MongoDB). 6. Notification Server: Pushes notifications through APNS and FCM. 7. Queues: Manages tasks with Kafka or SQS for seamless processing. 8. Workers & Consumers: Executes background tasks efficiently. 9. Big Data & Analytics : Collects and analyzes data for insights and improvements. 10. CDN: Delivers static content quickly and reliably. 11. Caching : Uses Redis for fast data retrieval. This architecture ensures high availability, scalability, and performance. 📈 🔍 Ready to scale your microservices? Let’s connect and discuss! #Microservices #Architecture #Scalability #TechInnovation #CloudComputing

2

A Jenkins Shared Library is generally used by numerous pipelines in an organization. However, it isn’t packaged and delivered with a fixed version, it is referenced directly from its git repo. How do you ensure stability in a fast-moving development environment, without versions? Most importantly, you must add CI to your CI. Every function you write should include unit tests that are executed on PR to your shared library repo. The UnitTest module gives you the ability to write mocks in groovy, so you can test that your functions execute according to expectation, without side effects or needing to access external systems. When possible, it is also advisable to add functional tests. Testing your own CI is something that isn’t commonly done, but saves hours of frustration and time and should be an absolute requirement. As with all testing, you probably won’t have full coverage of all use cases. To ensure stability in the pipelines using your library, you can use git tagging. When a new function set is ready, it should be tagged and published. When a shared library is declared in a Jenkins pipeline, it uses the master/main branch by default. You can specify a different branch, tag or commit explicitly. By using this functionality, each pipeline can fully control when to move to newer functionality. When a team is ready to try out the new functionality, they will stage their pipeline with the latest tag and migrate if it is successful. This will keep the pipelines stable and not having to worry about changes being pushed in underneath them. #iworkforgm #GMrs_lead

7

3 Comments

In microservices architecture, an operation that spans several services must use what’s known as a saga, a message-driven sequence of local transactions Sagas adhere to the ACD principles (Atomicity, Consistency, Durability), but they lack the isolation feature found in traditional ACID transactions As a consequence, applications need to employ countermeasures — design techniques that mitigate or minimise the effects of concurrency anomalies arising from the absence of isolation Three specific anomalies: 1️⃣ Lost updates: This occurs when one saga overwrites data without considering changes made by another saga 2️⃣ Dirty reads: In this scenario, a transaction or saga reads data that has been updated by another saga but hasn't completed those updates yet 3️⃣ Fuzzy/non-repeatable reads: When different steps of a saga read the same data and obtain varying results due to updates made by another saga A practical model for structuring a saga includes three types of transactions: 1️⃣ Compensatable transactions: These transactions can potentially be rolled back using a compensating transaction. 2️⃣ Pivot transaction: The pivotal point in a saga. If the pivot transaction commits, the saga proceeds until completion. The pivot transaction may be a non-compensatable or non-retriable transaction. Alternatively, it can be the last compensatable transaction or the first retriable transaction. 3️⃣ Retriable transactions: These transactions follow the pivot transaction and are guaranteed to succeed Uwe Friedrichsen, in his insightful blog, highlighted a crucial aspect of the saga versus distributed transaction debate: https://lnkd.in/ez2tTtg2 According to Uwe, the saga pattern shines when handling business level errors in a distributed context on top of a reliable technical layer; the saga pattern is specifically designed for handling business errors and enabling logical transaction rollbacks. It is less suitable for addressing technical errors Imagine encountering an unexpected error message while attempting to write to the DB – a technical error. In response, you decide to abort the business transaction using the saga pattern and trigger a compensating action. However, what if the compensating action also fails due to another technical error (bearing in mind that technical errors often occur in clusters)? The question arises: should there be a compensating compensating action? Concepts such as event sourcing, combined with snapshots, prove valuable. The approach involves replacing the faulty components of the system, loading the most recent snapshot, and subsequently replaying all events that occurred after that snapshot. Other techniques to consider are: 1️⃣ Retries with exponential backoff and jitter 2️⃣ Convergent and commutative replicated data types Sagas have garnered significant attention in various technical resources, occasionally with a negative perspective - please see: https://lnkd.in/edSvx3tR

6

𝐃𝐞𝐬𝐢𝐠𝐧𝐢𝐧𝐠 𝐄𝐯𝐞𝐧𝐭-𝐃𝐫𝐢𝐯𝐞𝐧 𝐌𝐢𝐜𝐫𝐨𝐬𝐞𝐫𝐯𝐢𝐜𝐞𝐬 𝐚𝐧𝐝 𝐢𝐭𝐬 𝐁𝐞𝐬𝐭 𝐩𝐫𝐚𝐜𝐭𝐢𝐜𝐞𝐬 𝐟𝐨𝐫 𝐝𝐞𝐬𝐢𝐠𝐧𝐢𝐧𝐠. Designing event-driven microservices involves creating systems that react to events (changes in state) rather than directly invoking services. This approach allows for more scalable, resilient, and flexible architectures. Here are some best practices for designing event-driven systems, with a focus on identifying events and designing event schemas. 𝐁𝐞𝐬𝐭 𝐏𝐫𝐚𝐜𝐭𝐢𝐜𝐞𝐬 𝐟𝐨𝐫 𝐃𝐞𝐬𝐢𝐠𝐧𝐢𝐧𝐠 𝐄𝐯𝐞𝐧𝐭-𝐃𝐫𝐢𝐯𝐞𝐧 𝐒𝐲𝐬𝐭𝐞𝐦𝐬 1. 𝐋𝐨𝐨𝐬𝐞 𝐂𝐨𝐮𝐩𝐥𝐢𝐧𝐠:   •  Ensure services are loosely coupled by using events for communication. This allows services to evolve independently. • Use event brokers (e.g., Kafka, RabbitMQ) to decouple event producers from consumers. 2. 𝐄𝐯𝐞𝐧𝐭 𝐒𝐨𝐮𝐫𝐜𝐢𝐧𝐠:     Store the state of an entity as a sequence of events. This approach helps in reconstructing the cu rrent state and allows for auditing and debugging. 3. 𝐈𝐝𝐞𝐦𝐩𝐨𝐭𝐞𝐧𝐜𝐲: Ensure that event handling is idempotent. Consuming the same event multiple times should not lead to inconsistent states. 4. 𝐒𝐜𝐚𝐥𝐚𝐛𝐢𝐥𝐢𝐭𝐲: Design your system to handle high volumes of events. Use partitioning and replication strategies provided by your event broker. 5. 𝐑𝐞𝐬𝐢𝐥𝐢𝐞𝐧𝐜𝐞 𝐚𝐧𝐝 𝐅𝐚𝐮𝐥𝐭 𝐓𝐨𝐥𝐞𝐫𝐚𝐧𝐜𝐞:      Implement retry mechanisms and dead-letter queues to handle failed event deliveries. 6. 𝐒𝐜𝐡𝐞𝐦𝐚 𝐄𝐯𝐨𝐥𝐮𝐭𝐢𝐨𝐧:    Design event schemas to be forward and backward compatible to handle versioning without breaking existing consumers. #Microservices #EventDriven #SoftwareArchitecture #TechRecruitment #HiringTechTalent #USRecruitment #Scalability #RealTimeProcessing #TechInnovation #ITRecruitment #TechJobs #HiringNow #SoftwareEngineering #USJobs #Recruitment #TechCareers #JobOpportunities #TechTalent #TalentAcquisition #DigitalTransformation #SystemDesign #SoftwareDevelopment #DistributedSystems #EventDrivenArchitecture #CloudComputing #AgileDevelopment

2

Building a Performant, Maintainable, and Resilient Application Creating an application that stands the test of time requires strategic planning and best practices. Here are key components to focus on: 1. Architecture & Design - Modular Architecture: Break down functionality into discrete, reusable modules. - Microservices: Independent, deployable services for scalability and fault isolation. - Design Patterns: Use proven patterns like MVC and Singleton for cleaner code. 2. Performance Optimization - Efficient Algorithms: Choose algorithms and data structures wisely. - Caching: Use Redis or Memcached to reduce redundant computations. - Asynchronous Processing: Leverage message queues for background tasks. - Load Balancing: Distribute traffic across multiple servers. 3. Maintainability - Clean Code: Follow SOLID principles and maintain readable code. - Documentation: Keep comprehensive documentation for onboarding and troubleshooting. - Version Control: Use Git with a clear branching strategy. - Code Reviews: Ensure quality through peer reviews. 4. Resilience - Error Handling: Implement robust error management. - Redundancy: Introduce redundancy to minimize downtime. - Automated Testing: Use unit, integration, and end-to-end tests. - Monitoring & Logging: Set up real-time monitoring with tools like Prometheus and Grafana. 5. Scalability - Horizontal Scaling: Add instances to handle increased load. - Database Scaling: Use sharding, replication, and NoSQL solutions. - API Rate Limiting: Protect your app from being overwhelmed by excessive requests. By focusing on these components, you can build applications that are efficient, easy to maintain, and resilient to challenges. #SoftwareDevelopment #TechLeadership #BestPractices #Scalability #PerformanceOptimization

16

Characteristics of a Microservices Architecture 1. Split into numerous components Software built using a microservices architecture is, by definition, broken down into numerous component services. Each service can be created, deployed, and updated independently without compromising application integrity. The entire application can be scaled up by tweaking a few specific services instead of taking it down and redeploying it. 2. Robust and resistant to failure It is not easy for an application built using a microservices architecture to fail. Of course, individual services can fail, undoubtedly affecting operations. After all, numerous diverse and unique services communicate with each other to carry out operations in a microservices environment, and failure is bound to occur at some point. However, in a correctly configured microservices-based application, a function facing downtime should be able to reroute traffic away from itself while allowing its connected services to continue operating. It is also easy to reduce the risk of disruption by monitoring microservices and bringing them back up as soon as possible in case of failure. 3. Simple routing process Microservices consist of intelligent components capable of processing data and applying logic. These components are connected by ‘dumb wires’ that transmit information from one element to another. This simple routing process is the opposite of the architecture used by some other enterprise applications. For example, an enterprise service bus utilizes complex systems for message routing, choreography, and the application of business rules. Microservices, however, simply receive requests, process them, and produce an appropriate output to be transferred to the requesting component. 4. Decentralized operations Microservices leverage numerous platforms and technologies. This makes traditional centralized governance methods inefficient for operating a microservices architecture. Decentralized governance is better suited for microservices as developers worldwide create valuable tools to solve operational challenges. These tools can even be shared and used by other developers facing the same problems. Similarly, a microservices architecture favors decentralized data management, as every microservice application manages its unique database. Conversely, monolithic systems typically operate using a centralized logical database for all applications. 5. Built for modern businesses Microservices architecture is created to focus on fulfilling the requirements of modern, digital businesses. Traditional monolithic architectures have teams work on developing functions such as UI, technology layers, databases, and server-side logic. Microservices, on the other hand, rely on cross-functional teams. Each team takes responsibility for creating specific products based on individual services transmitting and receiving data through a message bus

13

1 Comment

A picture is worth 1000 words.

1

The Power of the Architecture Tradeoff Analysis Method (ATAM) 🚀 Are you looking to ensure your software architecture aligns with business goals and meets quality attributes? The Architecture Tradeoff Analysis Method (ATAM) might be your answer. Let's see how ATAM can improve your architectural decision-making process. Why Use ATAM? ATAM is a structured framework to evaluate architectural decisions, focusing on key quality attributes like performance, modifiability, and security. It helps identify risks, sensitivities, and tradeoffs early in the development process, ensuring a robust and resilient architecture. Key Components of ATAM • Stakeholder Involvement: Engages diverse stakeholders to gather multiple perspectives. • Quality Attribute Scenarios: Defines specific, measurable scenarios to evaluate the architecture. • Architectural Approaches: Considers various strategies to achieve quality attributes. ATAM Process Overview 1. Present the ATAM: Introduce the method and its goals. 2. Present the Business Drivers: Understand the business context and objectives. 3. Present the Architecture: Describe the architectural approach. 4. Identify Architectural Approaches: Highlight the key strategies used. 5. Generate Quality Attribute Utility Tree: Prioritize and define quality attributes. 6. Analyze Architectural Approaches: Evaluate how well approaches address quality attributes. 7. Brainstorm and Prioritize Scenarios: Identify and rank relevant scenarios. 8. Analyze Scenarios: Assess scenarios for risks, tradeoffs, and sensitivity points. 9. Present Results: Summarize findings and provide actionable insights. Understanding Tradeoffs Tradeoffs are inherent in architecture. For instance, improving performance might impact modifiability. ATAM helps balance these by making explicit the costs and benefits of different decisions, ensuring a well-rounded architecture. Risks and Sensitivities • Risks: Potential issues that might hinder achieving quality attributes. • Sensitivities: Elements of the architecture critical for certain quality attributes. • Tradeoffs: Decisions impacting one quality attribute positively and another negatively. Benefits of ATAM • Early Identification of Issues: Detect problems early in the design phase. • Stakeholder Alignment: Ensure all stakeholders have a shared understanding. • Improved Decision Making: Make informed decisions based on structured analysis. Critique of ATAM Despite being a powerful tool, it is too formal for real life world. The shortened versions of it is used by service companies and consulting agencies. Typically, you would need to focus on the requirements, tradeoffs, consequences and risks to be 90% successful. #SoftwareArchitecture #ATAM #TechLeadership #SoftwareDevelopment #RiskManagement #QualityAttributes #ArchitectureDesign #TechCommunity #ProjectSuccess #ContinuousImprovement #SoftwareEngineering

6

3 Comments

Step by step tutorial on setting up #automation #framework for automating web applications using #cucumber, #selenium and #python with #allure #reports.. https://lnkd.in/edwgs32K

3

Nice....another pattern that we can apply is a cache-through pattern, which is a combination of 2 cache patterns, read-through and write-through. In a read-through cache pattern, when a cache miss occurs (i.e., the requested data is not found in the cache), the cache automatically fetches the data from the backend data source. The fetched data is then stored in the cache before being returned to the requester. Subsequent requests for the same data can be served directly from the cache until the cached data expires or is invalidated. A write-through cache pattern involves writing data to both the cache and the backend data source simultaneously. When data is updated or inserted, the cache is updated first, followed by updating or inserting the data in the backend data source. This ensures that the cache and the backend remain consistent, reducing the risk of stale data in the cache. In the cache-through pattern, the application delegates the responsibility of managing the cache to the underlying data access layer or caching framework. The data is fetched from the backend data source on cache misses (read-through), and updates are propagated to the backend data source immediately (write-through). This pattern ensures that the cache remains consistent with the backend data source while minimising the impact on performance. The application code is not directly involved in managing the cache. Instead, it interacts with the cache indirectly through the data access layer. In cache-aside pattern, the application has more control over caching behaviour, it also carries the responsibility of ensuring cache consistency and managing cache invalidation.

2

REST API Vs. GraphQL

5

Note: Posting again based on the feedback for better Video Quality. A step further into Apache Pulsar for Custom UI Angular Micro Front End and exploring the benefits of a layered architecture, and provides strategies to minimize latency issues. hashtag #ApachePulsar hashtag #ApacheKafka hashtag #AngularFederationMicroFrontends hashtag #SpringbootMicroservices hashtag #Java22

25