Mohit Dharmadhikari

Unreliable object states? Inconsistent object initialization? Data integrity issues? 🚀 Propel your code quality with C# Required Properties! 🚀 With required properties, your classes require initialization at compile-time, ensuring valid object states and reducing runtime errors. Say goodbye to half-baked objects and hello to robust, maintainable code! 🗨️ Do you frequently use required properties? Tell us more about it in the comments! #ASPNETCore #SoftwareArchitecture #dotnet #csharp #DesignAndArchitecture #CodeDesign

69

13 Comments

#Designing #Green and #Sustainable #APIs: A Focus on Rate Limiting In the journey towards greener and more sustainable software, API design plays a crucial role. Implementing strategies like #data #compression, #batch #requests, and rate limiting are just a few best practices that can make a significant difference. In this article, let’s take a closer look at rate limiting and how it contributes to more #sustainable #APIs. Rate limiting is a technique that controls how often clients or apps can access an API within a set timeframe. By enforcing clear thresholds, #rate #limiting ensures that #APIs remain efficient and responsive, even under high demand. #Sustainability in #tech starts with thoughtful #design. Let’s build #smarter, #greenerAPIs. Dont hesitate to read, correct, improve, share the article on the AXA en France blog 🙂 #GreenAPIDesign #GreenIT #GreenCoding #GreenByDesign #SustainableAPI #SustainableSoftware cc: Jean-Philippe EPRINCHARD Cyrille GRIFO Vincent Delaval Gilles CRUCHON Lionel Brat Antoine Bastin Abir Jellad François Descamps Sara Gutsatz Ana Gamito Amandine CARLIER Thierry Béhin Maxime Leleux Sofiane OUDINA Daniel Salomé Amaury Preclin Nicolas LINARD Camille Milleville Guilhem Cornette Cylia YACOUB Elodie B. Domingues Manuel Green Software Foundation Collectif API Thinking Read “Green API Design 1/5: Rates limiting for Sustainable APIs“ by Thierno Diallo on Medium: https://lnkd.in/eW-rNVwZ

27

3 Comments

Master Spring Boot: A Complete Guide to Essential Annotations 1. @SpringBootApplication 2. @EnableAutoConfiguration 3. @SpringBootConfiguration 4. @ComponentScan 5. @RestController, @Controller 6. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping 7. @ResponseBody 8. @PathVariable, @RequestParam 9. @CrossOrigin 10. @Component, @Service, @Repository 11. @Autowired 12. @Qualifier 13. @Primary 14. @Bean 15. @Value 16. @ConfigurationProperties 17. @PropertySource 18. @Profile 19. @Conditional 20. @Scheduled 21. @SpringBootTest, @DataJpaTest, @WebMvcTest, @JsonTest, @WebFluxTest 👍🏿 Subscribe to our newsletter - https://bit.ly/3x4j5dT #systemdesign #coding #interviewtips

769

17 Comments

Monolithic vs. Microservices Architecture: Which to Choose? 🤔 Monolithic Architecture 🏰 One Big Castle: Integrates all components (database, server, UI) into a single structure. Unified & Simple: Easier to develop and maintain due to its uniform structure. Scaling Challenges: Scaling requires all components to scale, which can be resource-intensive. Microservices Architecture 🌐 City of Specialized Buildings: Each microservice handles a specific task, like buildings in a city. Scalability & Flexibility: Enables scaling individual services as needed, optimizing resource use. Increased Complexity: Managing communication between services can be complex, despite decentralized advantages. Choosing Your Path 🛤️ Start Simple: Monoliths suit small to medium projects prioritizing simplicity. Modular Growth: Microservices excel in large, complex applications needing scalable independence or managed by multiple teams. Conclusion 🎯 No One-Size-Fits-All: Choose based on project needs and goals. Hybrid Approaches: Some opt for hybrid solutions blending benefits from both architectures. If you're new to these terms or looking to dive deeper, give this a ❤️ and share! Together, we can make tech jargon easier to grasp for everyone. 🌍 🤝Feel free to connect with me on a https://lnkd.in/dX_xTRgw image credit: Nelson DjaloMonolithic vs. Microservices Architecture: Which to Choose? 🤔 Monolithic Architecture 🏰 One Big Castle: Integrates all components (database, server, UI) into a single structure. Unified & Simple: Easier to develop and maintain due to its uniform structure. Scaling Challenges: Scaling requires all components to scale, which can be resource-intensive. Microservices Architecture 🌐 City of Specialized Buildings: Each microservice handles a specific task, like buildings in a city. Scalability & Flexibility: Enables scaling individual services as needed, optimizing resource use. Increased Complexity: Managing communication between services can be complex, despite decentralized advantages. Choosing Your Path 🛤️ Start Simple: Monoliths suit small to medium projects prioritizing simplicity. Modular Growth: Microservices excel in large, complex applications needing scalable independence or managed by multiple teams. Conclusion 🎯 No One-Size-Fits-All: Choose based on project needs and goals. Hybrid Approaches: Some opt for hybrid solutions blending benefits from both architectures. If you're new to these terms or looking to dive deeper, give this a ❤️ and share! Together, we can make tech jargon easier to grasp for everyone. 🌍 🤝Feel free to connect with me on a https://lnkd.in/dX_xTRgw image credit: Nelson Djalo

980

20 Comments

Looking for immutable value types? Found inefficient equality checks? Unclear value semantics? ⚡Discover the power of Record structs!⚡ Record structs—introduced in C# 10—are similar to record classes but designed for structure types. They offer a concise way to define data containers with value semantics. 👍 Advantages - `struct` provides value semantics, making them ideal for small data structures. - `record struct` allows for condensed and readable definitions of data structures. - `readonly record struct` makes the `record struct` immutable. - For `record struct` and `readonly record struct`, the compiler synthesizes equality implementation, which is more efficient than the reflection-based implementation in regular structs. 👎 Disadvantages - `struct` are passed by value, leading to performance overhead due to copying, especially true for large structs. ✅ When to Use - When you need a small, lightweight data container. - For immutable data structures, use `readonly record struct`. - When you prefer value semantics and the data structure's size is small. - When you need efficient equality comparisons for your `struct`. ❌When Not to Use - Avoid using record structs for large or complex data structures. a.k.a. follow the standard struct guidelines. 🆚Difference Between Record and Standard Struct - `record struct` have a compiler-synthesized equality implementation based on declared data members, which is more efficient. Standard `struct` use `ValueType.Equals(Object)` and rely on reflection, which is less efficient. - `record struct` provide concise syntax for declaring immutable data objects with positional parameters and `with` expressions for nondestructive mutation. ⚖️Difference Between Record Struct and Record Class - `struct` are value types, meaning they are passed by value, and each copy is independent. Classes are reference types, meaning they are passed by reference. - `record class' positional properties are immutable, while `record struct` positional properties are mutable by default but can be declared `readonly` to change this. 💡 Takeaways `record struct` provide a neat, efficient way to define small data containers with value semantics. Use them when performance and simplicity are key, but be cautious with larger structures to avoid unnecessary copying overhead. The compiler-synthesized equality implementation makes `record struct` an efficient choice for value-based equality. Understanding the differences between `record struct`, standard `struct`, and `record class` will help you choose the right type for your data structures. 📌Tips Default to using classes or record classes before using a struct. 💬Comments Have you tried record structs? What do you think of them? Share your thoughts in the comments below! #ASPNETCore #SoftwareArchitecture #dotnet #csharp #DesignAndArchitecture #CodeDesign #ProgrammingTips #CleanCode

40

7 Comments

"Empowering Microservices Architecture with 𝑪𝒊𝒓𝒄𝒖𝒊𝒕 𝑫𝒆𝒔𝒊𝒈𝒏 𝑷𝒂𝒕𝒕𝒆𝒓𝒏𝒔: Driving Scalability and Resilience 🛠️ In the realm of modern software development, microservices architecture has emerged as a game-changer, offering agility, scalability, and fault isolation. Yet, harnessing its full potential requires a deep understanding of robust design principles, much like the intricacies of circuit design patterns in electronics. Here's how circuit design patterns can be analogized to enhance microservices architecture: 1️⃣ 𝑹𝒆𝒔𝒊𝒍𝒊𝒆𝒏𝒄𝒆 𝒕𝒉𝒓𝒐𝒖𝒈𝒉 𝑪𝒊𝒓𝒄𝒖𝒊𝒕 𝑩𝒓𝒆𝒂𝒌𝒆𝒓𝒔: In electronics, circuit breakers prevent damage by interrupting the flow of electricity when a fault occurs. Similarly, in microservices, circuit breakers act as a safeguard, detecting failures in remote services and preventing cascading failures by temporarily halting requests. 2️⃣ 𝑳𝒐𝒂𝒅 𝑩𝒂𝒍𝒂𝒏𝒄𝒊𝒏𝒈 𝒂𝒏𝒅 𝑺𝒊𝒈𝒏𝒂𝒍 𝑨𝒎𝒑𝒍𝒊𝒇𝒊𝒄𝒂𝒕𝒊𝒐𝒏: Just as voltage amplifiers boost signals in electronics, load balancing mechanisms distribute incoming traffic across multiple instances of a microservice, ensuring optimal resource utilization and preventing overloading of any single component. 3️⃣ 𝑭𝒂𝒖𝒍𝒕 𝑻𝒐𝒍𝒆𝒓𝒂𝒏𝒄𝒆 𝒘𝒊𝒕𝒉 𝑹𝒆𝒅𝒖𝒏𝒅𝒂𝒏𝒄𝒚: Redundancy is a common strategy in both domains. In electronics, redundant components ensure system reliability. Similarly, in microservices, redundant instances of services or data replication safeguard against failures, ensuring continuous operation even in the face of node or service failures. 4️⃣ 𝑬𝒓𝒓𝒐𝒓 𝑯𝒂𝒏𝒅𝒍𝒊𝒏𝒈 𝒂𝒏𝒅 𝑭𝒆𝒆𝒅𝒃𝒂𝒄𝒌 𝑳𝒐𝒐𝒑𝒔: Feedback loops in electronics regulate system behavior based on measured outputs. Similarly, in microservices, error handling mechanisms provide feedback to the system, enabling adaptive strategies such as retry mechanisms or fallback mechanisms to gracefully handle errors and maintain system stability. By drawing parallels between circuit design patterns and microservices architecture, engineers can leverage established principles to design resilient, scalable, and fault-tolerant systems. Embracing this interdisciplinary approach fosters innovation and equips teams to navigate the complexities of modern software development with confidence. What other parallels between circuit design patterns and microservices architecture do you find intriguing? Share your insights in the comments below! Thank you! DM | Follow Mohamed Arafath for more learning and information. #Microservices #Architecture #CircuitDesign #SoftwareEngineering #Innovation #WebDevelopment #Design #SoftwareEngineering #DeveloperTips #BestPractices #softwaredesign #SoftwareDevelopment #arafattips🚀

6

1 Comment

🚀 Override Equals and GetHashCode in Records for custom comparisons 🚀 Did you know? In C#, records provide value-based equality out of the box! 🙌 But sometimes, you may need to compare records based on only specific properties. That’s where customizing Equals and GetHashCode comes into play. 🎛️ 💡 Why do this? Customizing these methods allows for partial comparisons in scenarios where only a subset of properties should determine equality. Perfect for when you only care about a few key details and want efficient comparisons! 🔍 In this example, two Product records are equal if they share the same Name—ignoring the Price property. Handy, right? — Join 9000+ subscribers! Stay in the loop with everything you need to know about .NET and Software Development ✉️ https://lnkd.in/dqrz6Tke 🛟 If you like this content, please, subscribe, comment and share — 💬 What’s a scenario where you’d need custom comparison logic? Drop your thoughts below! 👇 Let's chat about it! #dev #developer #programming #programmer #microsoft #csharp #dotnet #aspnet #blazor #razor #mvc #webapi #api #vs #vscode #ef #efcore

43

6 Comments

Null reference errors? Fragile code? Frequent runtime errors? ⚡Strengthen your codebase with Nullable Reference Types!⚡ Nullable reference types—introduced in C# 10—help us handle potential null reference errors more effectively by integrating nullability into the type system. 👍Advantages - Enhances code safety by identifying possible null reference errors at compile time. - Improves code readability and maintainability by explicitly marking nullable reference types. - Assists in preventing runtime null reference exceptions. 👎Disadvantages - Requires updating existing codebases, which can be time-consuming. - May produce numerous warnings in legacy code, making the initial adoption process challenging. - Do not stop null values from flowing at runtime; only do static analysis during the compilation. This reality is important for library authors to consider. ✅When to Use - When starting new projects to ensure null safety from the beginning. - During code refactoring to improve code quality and reduce runtime errors. - In large teams to enforce consistent handling of null references across the codebase. ❌When Not to Use - When working with legacy code that cannot be easily modified to accommodate nullable reference types. 💡Takeaways Nullable reference types provide a robust mechanism to handle null references, making our code more reliable. While the transition might require some effort, the long-term benefits in terms of code safety and maintainability are significant. Nullable reference types rely only on static analyzers, so runtime errors can still occur if external consumers call your code (or vice versa). 💬Comments Have you started using nullable reference types in your projects? Share your experiences and tips below! #ASPNETCore #SoftwareArchitecture #dotnet #csharp #DesignAndArchitecture #CodeDesign #ProgrammingTips #CleanCode

96

20 Comments

Imagine that you manage APIs in production by using Azure API Management. You need to remove X-Powered-By and X-AspNet-Version headers from a response. 💡 Which code segment should you use? To remove the X-Powered-By and X-AspNet-Version headers from a response in Azure API Management, you can use a policy expression within the <outbound> section of your API configuration. This XML snippet should be placed within the <policies> element of your API configuration in Azure API Management. 💡 Explanation The <outbound> element is used because we want to modify the response headers after they've been generated but before they're sent back to the client. We use two <set-header> elements: - One for X-Powered-By - Another for X-AspNet-Version The exists-action="delete" attribute tells Azure API Management to delete these headers if they exist in the response. This approach works at the API level, so it will apply to all operations within this API unless overridden. If you only want to apply this to specific operations, you can place the <outbound> section inside individual <operation> elements instead of at the API level. #az204 #microsoft #azure #learning

58

12 Comments

Monolithic vs. Microservices Architecture: Which to Choose? 🤔 Monolithic Architecture 🏰 One Big Castle: Integrates all components (database, server, UI) into a single structure. Unified & Simple: Easier to develop and maintain due to its uniform structure. Scaling Challenges: Scaling requires all components to scale, which can be resource-intensive. Microservices Architecture 🌐 City of Specialized Buildings: Each microservice handles a specific task, like buildings in a city. Scalability & Flexibility: Enables scaling individual services as needed, optimizing resource use. Increased Complexity: Managing communication between services can be complex, despite decentralized advantages. Choosing Your Path 🛤️ Start Simple: Monoliths suit small to medium projects prioritizing simplicity. Modular Growth: Microservices excel in large, complex applications needing scalable independence or managed by multiple teams. Conclusion 🎯 No One-Size-Fits-All: Choose based on project needs and goals. Hybrid Approaches: Some opt for hybrid solutions blending benefits from both architectures. If you're new to these terms or looking to dive deeper, give this a ❤️ and share! Together, we can make tech jargon easier to grasp for everyone. 🌍 🤝Feel free to connect with me on a https://lnkd.in/dX_xTRgw image credit: Nelson Djalo

1,305

71 Comments

You can REASSIGN an approval in #PowerAutomate using this hidden API endpoint 🤝 URI: https:// approvals .teams. microsoft. com /api/reassignApproval Body: { "AssignedTo": "@{variables('varAssignedTo')}", "ApprovalId": "@{variables('varApprovalId')}", "ApprovalRequestId": "@{variables('varApprovalRequestId')}", "Properties": { "Response": "", "Comments": "" }, "FlowEnvironment": "@{workflow()?['tags']?['environmentName'] }" } Go to the comments of this post for the full article 👇

630

35 Comments

I wrote a blog post on #dotnet core after a long time 🙏 Title - Reading Request Headers Across Multiple .NET Core API Controllers 🔥 Read here - https://lnkd.in/g4mjbexW IHttpContextAccesor should be helpful if you are working on #dotnet.😍 #csharp #geek97 #mvpbuzz

42

🤔 How to ensure the uptime and reliability of APIs? 👉 First thing first we need the design the system in a way that - 🔹rely on redundancy, 🔹invest and deploy in multiple nodes, 🔹have multiple load balancers placed on frontend to distribute the work loads - which helps meet the availability SLA and also improve system performance & user experience, enabling failover and almost zero message loss as well as horizontal scaling. 👉 At the same time we need to identify key metrics to monitor the API and take corrective measures [for an example - build an ML model to prevent out of memory kill events], which could be at - 0️⃣ Infra level 🔸Uptime - think about 9s 🔸CPU usage 🔸Memory usage etc. 1️⃣ Application level 🔸Request per minute (RPM) 🔸Average & max latency - could as well monitor percentiles 🔸Error per minute etc. 2️⃣ Product level 🔸API usage growth 🔸Unique API consumers 🔸Top consumers by API usage 🔸API retention 🔸First call 🔸Calls per business transaction 🔸SDK version adoption etc. 3️⃣ Business level 🔸Revenue 🔸Adoption 🔸Customer Success etc. What else? #GenAI #apis #design #ml #userexperience

10

1 Comment

Looking to dive into microservices? Check out Rocky Bhatia's crash course for a quick intro! #microservices #technology #learning #softwaredevelopment https://lnkd.in/d2n624WY

2

#𝐉𝐚𝐯𝐚𝐬𝐜𝐫𝐢𝐩𝐭 𝐔𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝𝐢𝐧𝐠 𝐨𝐟 𝐒𝐡𝐚𝐥𝐥𝐨𝐰 𝐯𝐬 𝐃𝐞𝐞𝐩 𝐜𝐨𝐩𝐲𝐢𝐧𝐠 𝐢𝐧 𝐉𝐚𝐯𝐒𝐜𝐫𝐢𝐩𝐭 If you want to create a deep copy of a simple object, consider using libraries like Lodash or implementing a custom deep cloning solution, such as using JSON.parse() and JSON.stringify(). 𝐒𝐡𝐚𝐥𝐥𝐨𝐰 𝐂𝐨𝐩𝐲 A shallow copy creates a new object, but it references the same underlying values as the original object. This means that if you modify a property in the original object, the change will also be reflected in the copied object, and vice versa. // 𝐒𝐡𝐚𝐥𝐥𝐨𝐰 𝐜𝐨𝐩𝐲 𝐮𝐬𝐢𝐧𝐠 𝐭𝐡𝐞 𝐬𝐩𝐫𝐞𝐚𝐝 𝐨𝐩𝐞𝐫𝐚𝐭𝐨𝐫 const shallowCopy = { ...originalObject }; modifying the original object's address also changes the shallow copy's address 𝐃𝐞𝐞𝐩 𝐂𝐨𝐩𝐲 A deep copy, on the other hand, creates a new object and recursively copies all of its properties, including nested objects. This means that modifying the original object will not affect the copied object. // 𝐃𝐞𝐞𝐩 𝐜𝐨𝐩𝐲 𝐮𝐬𝐢𝐧𝐠 𝐉𝐒𝐎𝐍.𝐩𝐚𝐫𝐬𝐞(𝐉𝐒𝐎𝐍.𝐬𝐭𝐫𝐢𝐧𝐠𝐢𝐟𝐲()) const deepCopy = JSON.parse(JSON.stringify(originalObject)); #javascript #shallowcopy #deepcopy In the upcoming post, it will be about when to use shallow and deep copy! Stay tuned!

1

Quote: The DDD (Domain-Driven Design) Trilemma deals with three often-conflicting goals: domain model encapsulation, domain model purity, and performance. Out of these three attributes only one can be considered as a software system quality attribute or, as they often called - architecturally significant requirements that require architect attention. Everything else is made up DDD BS terminology. Domain model purity, c'mon, like anyone cares. The real performances dilemma comes from a severe performance degradation when we try to model everything with memory objects and classes (OOP), even when it's not suitable, appropriate or necessary.

10

10 Comments

Smart contracts using C#.net: Neo Devpack Dotnet is a comprehensive toolkit for creating Neo contracts using .net. It offers convenient contract project templates and a compiler. https://lnkd.in/gueHp977

2