Thomas Enocsson’s Post

After some months of silence, we finally managed to publish the 3rd post and last post in our series on how to reduce costs in software development. The blog is co-written with my brilliant colleague Thomas Enocsson and covers the topics on how to optimize test and verification costs within software development. Enjoy and please share your thoughts!

Understanding the principles of component cohesion is pivotal for designing maintainable and scalable systems in the complex software development ecosystem. Component cohesion refers to the degree to which the elements of a module belong together. Why does this matter? High cohesion within a component ensures that it is focused on a single task, leading to easier software to understand, debug, and test. This not only streamlines development processes but also enhances the robustness of the architecture. Applying these principles practically involves scrutinizing how tightly related and focused the functionalities within each component are. For instance, a well-designed component should handle a specific functionality segment entirely and not be cluttered with disparate tasks that could be logically separated. This can be achieved by following the Single Responsibility Principle (SRP), one of the SOLID principles, which advocates for a component to have one reason to change. This might mean designing a user authentication system that exclusively handles user credentials and sessions without intertwining user profile management. To bring these benefits into your environment, evaluate existing components for potential refactoring opportunities where functionalities can be more tightly aligned. Tools such as static code analyzers can help identify violations of cohesion principles. Implementing unit tests focusing on specific functionalities can also indicate cohesion levels, as highly cohesive components tend to have more straightforward and predictable tests. Ultimately, the goal is to create a codebase where each component clearly and independently contributes to the overall functionality, reducing complexity and enhancing the adaptability of your software architecture. By fostering high cohesion within your components, you position your projects to be more flexible, less prone to bugs, and easier to scale, all of which can lead to a more prosperous and sustainable software architecture. #SoftwareArchitecture #ComponentCohesion #SOLID #SingleResponsabilityPrinciple #TDD #Refactoring

In the fast-paced world of tech, staying stagnant is not an option, especially when it comes to your software testing strategy. Just as software architecture must evolve with shifting business priorities and new technologies, your testing approach needs to keep pace. It's important to acknowledge the value of an 'Evolutionary Testing Strategy.'" Ignoring this evolution is like trying to ride a tricycle with one fixed wheel... eventually, you’ll tip over. This article shares some great steps to keep your testing strategy agile and aligned with the ever-changing landscape: https://heyor.ca/gkKmk7 #EvolutionaryTesting #SoftwareQuality #ARUVI #Testing

What’s a change? Like many engineering teams, we rely heavily on feature flagging to decouple deployment from feature releases. It helps us with incremental roll out, roll back, and product experimentation. And more, we see it as an essential practice for continuous integration. But if like us, you deliver software in a regulated environment, you are obliged to keep records for how your systems change. Of course you can track environment changes with Kosli, but how do we keep track of feature flag? Today I’m so happy that we can announce our Launchdarkly integration. Now you can record complete audit trails for every flag change automatically. So now, when the auditor asks for the list of changes to a product, you can skip the spreadsheets and screenshots and export directly from Kosli! To learn more about this, and all the other features released this month, check out our September changelog: https://lnkd.in/eECEmM8K

In the fast-paced world of tech, staying stagnant is not an option, especially when it comes to your software testing strategy. Just as software architecture must evolve with shifting business priorities and new technologies, your testing approach needs to keep pace. It's important to acknowledge the value of an 'Evolutionary Testing Strategy.'" Ignoring this evolution is like trying to ride a tricycle with one fixed wheel... eventually, you’ll tip over. This article shares some great steps to keep your testing strategy agile and aligned with the ever-changing landscape: https://heyor.ca/gkKmk7 #EvolutionaryTesting #SoftwareQuality #ARUVI #Testing

Shipping fast with legacy code can feel like running a race while dragging a boulder. But with the right approach, that heavy, outdated system can evolve into a streamlined engine of progress. You don’t need a full rewrite to make big changes—just smart tactics that help you move fast without breaking things. Here’s how you can turn your legacy code into a launchpad for rapid development, without compromising quality or stability. So when I see a legacy codebase from which I have to ship some features I keep the following points in mind. 1. Understand the System Before making changes, audit the codebase and update documentation. Knowing the architecture and dependencies helps avoid mistakes and identify quick wins. 2. Gradual Testing Start with unit tests for critical parts of the code, and add integration tests to cover key workflows. Prioritize the areas most prone to failure. 3. Break Down Features Ship features incrementally using feature flags. Refactor small, isolated sections instead of doing large rewrites. 4. Refactor Opportunistically Whenever you touch a part of the system, improve it. Small improvements over time keep the codebase healthy. 5. Isolate Legacy Components Isolate fragile legacy components through modularization or microservices. Use facades to ease the transition to new systems. 6. Automate Processes Use CI/CD pipelines to automate builds, testing, and deployments. Automate static analysis to maintain code standards. 7. Risk Mitigation Roll out new features carefully with blue-green deployments or canary releases to catch issues early. Have rollback plans in place. 8. Budget for Tech Debt Dedicate part of your sprint to reducing technical debt. Focus on the most critical areas that slow development down. 9. Improve Collaboration Could you make sure all teams are aligned on priorities and constraints? Consistent coding standards help prevent further accumulation of tech debt.

Struggling with Embedded Software Architecture? You’re not alone! Building robust embedded systems isn’t just about writing good code—your architecture needs to be rock-solid. Yet, many developers fall into common traps that sabotage their projects. In my latest blog post, I dive into the 5 biggest challenges developers face when architecting embedded systems. These include: 1) Trusting the 'Evolutionary' Approach 2) Ignoring the Data-First Approach 3) Overlooking Real-Time Response Requirements 4) Lacking a Feedback Loop Between Architecture and Implementation 5) Selecting the Wrong Architecture for the Job Curious to see where you might be going wrong and how to set things right? 👉 Read the full blog at

I was intrigued by the potential of integrating Infrastructure from Code (IfC) into Platform Engineering, so I wrote an article exploring this concept. In the article, I share my thoughts and discuss how IfC can serve as a platform orchestrator for an Internal Developer Platform. You can read it here: https://lnkd.in/gePTrqZs.

High cohesion within a component ensures that it is focused on a single task, leading to easier software to understand, debug, and test. Read more 👉 https://lttr.ai/AY3kZ #ComponentCohesion #ExtremeProgramming #SoftwareArchitecture #SpecificFunctionalitySegment #ComponentCohesionRefers #SingleTask #StreamlinesDevelopmentProcesses #HighCohesion #SpecificFunctionalities #CohesionLevels #StaticCodeAnalyzers #SingleResponsibilityPrinciple

World outages remind us of the importance of reducing dependencies on third parties and encourage us to build loosely coupled software. Loose coupling and high cohesion make your software more flexible, maintainable, and scalable. In software development, the less your code depends on other parts, the easier it is to change. Here's how to develop loosely coupled code: - Use Interfaces and Abstract Classes: Specify contracts for components to easily swap implementations. - Dependency Injection: Inject dependencies rather than hard-coding them for flexibility. - Encapsulate Change: Isolate change-prone parts from stable parts of the code. - Apply Design Patterns: Use patterns like Strategy, Observer, and Factory to achieve loose coupling. - Favor Composition Over Inheritance: If possible, assemble behaviors dynamically using composition. - Use Event-Driven Architecture: Facilitate communication via events to reduce direct dependencies. - Encourage Modularity: Break code into self-contained modules with well-defined interfaces. - Avoid Global State: Minimize global state to reduce dependencies and improve testability. - Write Clean, Understandable Code: Keep code clean to simplify refactoring and maintenance. - Use Service Layers: Abstract business logic into service layers to separate concerns. - Implement SOLID Principles: Follow SOLID principles to ensure better code organization and design. - Apply Separation of Concerns: Separate different functionalities into distinct sections of code. - Utilize Automated Testing: Write unit tests to ensure components work independently and correctly.