Ayman Anaam’s Post

Today's lesson was about applying the Single Responsibility Principle (SRP). Honestly, it wasn’t difficult, but I feel that it’s rare to see it properly implemented. SRP emphasizes that each class should have only one responsibility and should focus solely on one part of the system without interfering with other services. Benefits of SRP: Improved maintainability: Since each class has a single responsibility, changes can be made easily without affecting unrelated parts of the system. Enhanced readability: Code becomes easier to understand because each class handles a specific function. Better testability: Since each class focuses on one thing, testing becomes more straightforward and less complex. (I don't do the testing Lol) Simplifies debugging: When an issue arises, you can easily locate where the problem is because the functionality is compartmentalized. Increased scalability: It’s easier to extend or modify individual components without breaking the whole system. In summary, SRP makes your code cleaner, easier to manage, and more scalable.

𝗦𝗢𝗟𝗜𝗗 - 𝗧𝗵𝗲 𝗦𝗶𝗻𝗴𝗹𝗲 𝗥𝗲𝘀𝗽𝗼𝗻𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗦𝗥𝗣) The Single Responsibility Principle (SRP) is the "𝗦" in SOLID, and it states that: A class should have only one reason to change. In simple terms, a class should be responsible for only one thing. If a class handles multiple responsibilities, it becomes harder to maintain and modify without affecting unrelated functionality. 𝗕𝗲𝗻𝗲𝗳𝗶𝘁𝘀 𝗼𝗳 𝗦𝗥𝗣: 1. 𝗘𝗮𝘀𝗶𝗲𝗿 𝗺𝗮𝗶𝗻𝘁𝗲𝗻𝗮𝗻𝗰𝗲: When a class has only one responsibility, changes are less likely to have unexpected side effects. 2. 𝗜𝗺𝗽𝗿𝗼𝘃𝗲𝗱 𝘁𝗲𝘀𝘁𝗮𝗯𝗶𝗹𝗶𝘁𝘆: You can write focused unit tests for each responsibility. 3. 𝗦𝗲𝗽𝗮𝗿𝗮𝘁𝗶𝗼𝗻 𝗼𝗳 𝗰𝗼𝗻𝗰𝗲𝗿𝗻𝘀: It's clear which class handles which functionality, making the code easier to understand. 𝗖𝗼𝗻𝗰𝗹𝘂𝘀𝗶𝗼𝗻 Following the Single Responsibility Principle helps keep classes focused and manageable. In larger systems, this will result in fewer bugs, easier modifications, and a more modular codebase. Have you encountered a situation where violating SRP made a project harder to maintain? How did you resolve it, and what changes did you implement to avoid similar issues in the future?

LLMS can help in various cases in the implementation process including validating a problem and its proposed solution before implementing it, checking the quality of the applied solution/code against logical errors, refactoring code blocks after implementing a working solution, and building unit tests for the applied changes. Another handy perk of using LLMS is the ability to pair program with it during implementation to cut code re-visit and refactoring time. In the example below, an if condition that was previously written in the code became less readable after adding more logic to it. Instead of spending time optimizing its readability manually, passing it to an LLMS with (readability) as the refactoring goal will get the job done in a second during the implementation and you can self-review the result afterward and add your retouches. This minimizes the review/changes cycle and saves your time re-visiting an old PR from last week that you probably forgot what it was doing 😬.

"I cannot write tests because the requirements are not clear." I understand that you're either scared or lazy, but the statement is just a lame excuse. If you know the inputs and the outputs, you can write the test. If you don't, lock yourself in a room with the stakeholders and discuss and dig through, until you know them. Edit: There is a recurring theme in the comments, which is "the tests you write for unclear requirements are going to be completely rewritten anyway". The post is about writing tests at the boundary of the domain model. That boundary contains: the use cases (the SUT), the DTOs, and the pure fabrications for I/O (most commonly the test doubles for the repositories). This boundary is unlikely to change, even with changing requirements. If requirements change, there will be only punctual assertions which will change, potentially with slight changes to the test doubles. That being said, you can further reduce this risk of change by asserting in most test just that the system works correctly or fails correctly, and not concrete values in absolutely each test. Either way, writing the tests does not imply that they will be green in the beginning. They will just compile and fail, becoming green as the implementation progresses. Use them to measure progress. #tdd #softwarearchitecture #requirements

Single Responsibility Principle (SRP) is the bedrock of SOLID principles, ensuring each class in your software has only one reason to change, leading to more maintainable and scalable code.

Read a blog post about the Single Responsibility Principle earlier today. The author pointed out that it means a function should do one thing. While there’s a principle like that, it applies at the lower-level (when refactoring large functions into smaller ones). The SRP talks about code at the module level. The SRP stipulates that a module should only have one reason to change, and one reason only. The “reason to change” refers to users or stake holders. A direct violation of this rule is putting code that are responsible to different “actors”, in one class. By “actors,” I’m referring to users or stakeholders.

I just finished reading the book Specification by Example by Gojko Adzic. Although the book is from 2011, it contains a few gems worth reading. What made me smile though is, that many of the key statements remind me a lot of what #EventModeling is giving us, and then some. Book Summary: The central idea of “Specification by Example” is that examples, derived collaboratively, can serve as a single source of truth for software requirements, guiding development and testing. By specifying requirements using concrete examples, teams can avoid the ambiguities and misunderstandings that often arise from abstract or incomplete specifications. These examples help ensure that everyone involved—from business stakeholders to developers and testers—has a shared understanding of what the system should do. https://lnkd.in/dS5maCwN

Recently, I have seen some publications on the topic of SOLID principles, and almost always the most mentioned is the first of these principles, the Single-Responsibility Principle. Along with the mention, most reproduce the idea that this principle is about a class having only one responsibility. But the story is not quite like that. The central idea of the SRP is that each module should be responsible for a single functional aspect of the system, which implies that changes to this module should be requested by a single group of stakeholders. This avoids confusion and interference between different concerns, such as changing a financial method not affecting the audit operation, for example. This also increases cohesion (items related for the same reason) and decreases coupling (items related for different reasons). Therefore, the SRP suggests that, when developing software, we should isolate potential changes so that each module responds exclusively to a single concern or group of users, maintaining a clear separation of responsibilities. Want to know more?

Your debugging skills can make or break your OA performance! 🚀 While giving an Online Assessment (OA), it’s not just about writing code—debugging efficiently plays a crucial role in cracking it. But to debug well, you first need to know the errors you might encounter! Here are some common code-related errors I learned to tackle on my journey: 💻 Segmentation Fault: Accessing memory you shouldn’t—like out-of-bounds arrays or null pointers. ⏳ Time Limit Exceeded (TLE): A signal that your algorithm isn’t efficient enough. 🔧 Compilation Errors: Usually due to syntax mistakes or missing libraries. ⚡ Runtime Errors: Think division by zero or memory limit exceeded. ❌ Wrong Answer (WA): Caused by logic errors or missing edge cases. 🔄 Infinite Loops: The trap of incorrect loop conditions. Each of these errors taught me something valuable and helped me improve my problem-solving and debugging skills. 💡 Pro Tip: Always test edge cases and analyze your algorithm’s efficiency before hitting "Submit." #OnlineAssessment #Debugging #CodingJourney #ProblemSolving #productivty

🚨 Endor Labs Annual Dependency Management Report is Here! 🚨 We’ve uncovered some game-changing insights: 1. 9.5% of vulnerabilities are exploitable at the function level. 2. 98% noise reduction with reachability analysis + EPSS. 3. 95% of version upgrades include at least one breaking change. Why read it? If dependency management feels overwhelming, this report helps you cut through the noise with clear, actionable insights - No forms, just pure value. Check out the interactive report, download the PDF, or join our live recap on September 24th! (Link in comments)