<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Software Improvement Group - Medium]]></title>
        <description><![CDATA[Getting Software Right for a healthier digital world: https://softwareimprovementgroup.com - Medium]]></description>
        <link>https://medium.com/softwareimprovementgroup?source=rss----b58f22d3f9ab---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Software Improvement Group - Medium</title>
            <link>https://medium.com/softwareimprovementgroup?source=rss----b58f22d3f9ab---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 14:09:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/softwareimprovementgroup" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Using Architecture Decision Records to guide your architecture choices]]></title>
            <link>https://medium.com/softwareimprovementgroup/using-architecture-decision-records-to-guide-your-architecture-choices-ec2352fd8cce?source=rss----b58f22d3f9ab---4</link>
            <guid isPermaLink="false">https://medium.com/p/ec2352fd8cce</guid>
            <category><![CDATA[documentation]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[architectural-design]]></category>
            <category><![CDATA[adr]]></category>
            <category><![CDATA[docs-as-code]]></category>
            <dc:creator><![CDATA[Bruno Oliveira]]></dc:creator>
            <pubDate>Thu, 23 Feb 2023 06:26:06 GMT</pubDate>
            <atom:updated>2023-02-23T06:26:06.303Z</atom:updated>
            <content:encoded><![CDATA[<p>Learning how to use Architecture Decision Records can help you make better architectural choices over time</p><h3>Introduction</h3><p>In modern software development, the only constant is change: business needs evolve over time, features are added, expanded or removed accordingly, and development teams doing the work themselves are also subject to change over time. All this makes the whole software development process more complex and uncertain.</p><p>As such, it is becoming increasingly important for software development teams to find ways to manage complexity and ensure that both current and future development work is done while taking into account all the decisions that have been made before.</p><p>By doing so, all the changes that have happened over time can be leveraged today, so that better decisions can be made tomorrow.</p><p>One of the ways that the SIG development team found effective in enabling better decision-making is the use of <strong>Architecture Decision Records — ADRs</strong>, for short.</p><p>We will look at what an ADR is, as a general concept, as it’s not really new nor unique to SIG, and then we will detail how we “implement it” in practice for our specific context.</p><h3>What is an ADR, and why use it?</h3><p>As discussed above, any production-grade software product will always be backed by a shifting landscape behind the scenes: changes in business requirements, changes to the teams that write and maintain the software, and external changes, like new framework and language versions that open up many possibilities and deprecate others.</p><p>With so many changes, it can become impossible for a team to keep track of everything taking place in all the different areas that make up a software product.</p><p>As a result, something needs to be introduced within the team’s development process that allows teams to manage all this inherent complexity in a way that is effective, has low overhead, and can actually be kept somewhere.</p><p>In this way, it can be consulted when needed or desired, and can be tracked over time. Ideally, kept in version control so that it can evolve and “sit next” to the actual code, where architectural decisions will more likely be materialized, why?</p><p>Because architectural decisions are usually made taking the current software architecture into account. When code changes, and we want to document how and why it needed to change, it’s only logical to keep these close together.</p><p>By keeping this decision-making process in version control, next to the code, we benefit from locality and visibility. It turns out that such a standardized way of doing this already exists and is in practice described and used by the software engineering community formally called an “<strong>Architecture Decision Record”.</strong></p><p>Looking at ThoughtWorks’s nice description on their Technology Radar on<a href="https://www.thoughtworks.com/en-us/radar/techniques/lightweight-architecture-decision-records"> this</a> exact topic, we can describe a “lightweight” version of an Architecture Decision Record as a <a href="http://thinkrelevance.com/blog/2011/11/15/documenting-architecture-decisions">technique</a> for capturing important decisions with their context and consequences.</p><p>The structure of an ADR can vary depending on various aspects, such as your specific goals when using it, the level of maturity of the team that wants to implement it, etc., but as a general structure, the image below is a good starting point:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_VmsH_vHcdJKEVVs" /></figure><p>Figure 1 — Example structure of a lightweight ADR (Source: <a href="https://www.redhat.com/architect/architecture-decision-records">RedHat</a>)</p><p>Let’s quickly dissect the above structure and look at the usefulness of each field and how they, as a whole, provide a cohesive view of all the significant architectural decisions made during the life of a project. Let’s take a look at how to structure an ADR for a particular example.</p><p><strong>Small case study: </strong>at a certain point in time, it was decided that a specific DB table T would not be queried directly anymore in favour of using a service S which proved to be more reliable and easier to test.</p><p>Based on the above case study, let’s see what an ADR would look like:</p><ul><li><em>Identifier/Date</em>: <strong>both</strong> the identifier and the date are very significant. The identifier (which can be as simple as a number) can serve as the means to sort the various records in a logical order when viewed simply as a list of decisions. The date is useful to have a way to “anchor” in time when a particular architectural decision was introduced into a system.<br><strong>E.g.: “1. (21–02–2023) …”<br></strong>This makes it easier to look back in time and identify key moments of the project’s evolution, which is useful for both new joiners and more experienced members of a team to have a good overview of how the system evolved.</li><li><em>Title</em>: self-explanatory. A title is usually tied to some business or technical decision that was worth capturing, and people familiar with the domain should immediately derive the necessary context from the title.<br><strong>E.g. “Direct table T query deprecation in favor of usage of service S”</strong></li><li><em>Context</em>: the context provided about <strong>why</strong> this architectural decision was made. This section explains the factors that led to the decision. These can be technical factors, for example a vulnerability in a key library was discovered, and now a change is required to cope with it, or the business introduces requirements that disrupt existing architecture, etc.<br><strong>E.g. “Due to reliability issues and a hard time testing the business logic when we query a DB table directly, since correctness via testing and encapsulation via services is preferred, we have decided to introduce a new service to handle this piece of business logic.”</strong></li><li><em>Decision</em>: the actual decision. This section is the “meat on the bone” of an ADR, and it describes in detail what has changed and how the change was materialized in the domain, be it through code, documentation or a new process being introduced, but either way, all of that is described here.<br><strong>E.g. “A new service will be introduced in package x.y.z which will encapsulate the logic that was covered by the old direct DB query. The service must rely on using Hibernate to abstract the low-level details as much as possible to gain future flexibility when working on this area of the codebase.”</strong></li><li><em>Status</em>: the status of the ADR is used to indicate to who will read the document in the future whether the decision is “effective”, as in approved, validated and in use, or whether it’s under review, abandoned, etc. There is no standard for the statuses used, as long as they clearly and unambiguously indicate the usage of the decision in practice.<br><strong>E.g. “Status: Approved”</strong></li><li><em>Consequences</em>: the consequences describe the current state of the system after the ADR comes into effect. This section indicates how the system has changed and how the new set of changes will affect people working on the system from that point onwards. Documenting these consequences gives us a good overview of the evolution of the system and how it is shaping up as business requirements demand, and it can be an invaluable resource for processes like onboarding new people and getting them up to speed quickly.<br><strong>E.g. </strong>“<strong>No longer query table T, instead use service S which will be the standard operating procedure from now on.”</strong></li></ul><p>While not all lightweight ADRs have to follow this exact structure, these sections are usually present in an ADR. They provide a great overview of the tandem between software and the business itself while being extremely valuable as a resource for sharing knowledge, upskilling the entire team, and onboarding new people.</p><h3>How we use ADRs at SIG</h3><p>Now that we’ve looked at ADRs in general and how they can bring several benefits to a software development team, let’s look at how an ADR is written in practice at SIG.</p><p>There can be many ways to materialize an ADR, but for our use, and since we use lightweight ADRs, we decided to take the simplest approach that works.</p><p>At the top level of our backend repository, we have a docs folder, and one level down we have another folder named architecture_decision_record. By having it as a folder in our top-level repository, we immediately take advantage of the benefits of version control, so every change we make to our ADRs is documented in our version control systems, which is a great advantage for traceability and history.</p><p>Each individual ADR is created as a Markdown document that follows a specific template that is very similar to the one shown above: the convention when naming a newly created markdown file is the format: XXX — &lt;a descriptive title highlighting the decision&gt; where XXX is a number so all the decisions can be ordered, and the title very generically describes the purpose and content of the document.</p><p>As for the structure of the document itself, it contains six main sections that we leverage, many of which overlap with what is described above: date, status, context, decision and consequences.</p><p>The SIG template we use also includes an additional field called “<strong><em>Other options considered”.</em></strong> As the name implies, this is a dedicated section of an ADR where we look at different options that we have considered before making a final decision. The value of this section is that we become broader and more open-minded in terms of what is possible within our tech stack, what we can do or cannot do, and it’s also a way to stretch the limits of our own codebase, where sometimes performance improvements or optimizations can be hiding “in plain sight”.</p><h3>Conclusion</h3><p>We hope this blog showed you the value of adopting ADRs within your own software projects and teams. It is a simple, low-overhead way of documenting architectural decisions that offer many additional benefits, like traceability of decisions over time, trade-offs, and how the codebase and business change over time, and serves as a historical record of a project’s life cycle. By adopting it, you also help newcomers to the team immediately gain context that might otherwise be lost by being considered “institutional knowledge”. Making these decisions visible will increase team and project resilience over time and make it easier to make better and more well-informed decisions to guide the projects and teams to their maximum potential.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec2352fd8cce" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softwareimprovementgroup/using-architecture-decision-records-to-guide-your-architecture-choices-ec2352fd8cce">Using Architecture Decision Records to guide your architecture choices</a> was originally published in <a href="https://medium.com/softwareimprovementgroup">Software Improvement Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Improving loading times of data-rich dashboards with async workloads in Spring Boot]]></title>
            <link>https://medium.com/softwareimprovementgroup/improving-loading-times-of-data-rich-dashboards-with-async-workloads-in-spring-boot-13765cec7012?source=rss----b58f22d3f9ab---4</link>
            <guid isPermaLink="false">https://medium.com/p/13765cec7012</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[performance]]></category>
            <dc:creator><![CDATA[Bruno Oliveira]]></dc:creator>
            <pubDate>Tue, 27 Dec 2022 09:27:44 GMT</pubDate>
            <atom:updated>2022-12-27T09:27:44.517Z</atom:updated>
            <content:encoded><![CDATA[<h3>Sigrid® consists of several features. Up until now, each of our models’ characteristics had its dedicated user interface page and a single, unified “central hub” dashboard was missing from the platform. While building this dashboard, we learned a lot about how to leverage Spring Boot’s capabilities for running asynchronous workloads and how we could leverage that for this particular use case.</h3><p>The software quality models that SIG uses for its flagship product — <a href="https://www.softwareimprovementgroup.com/solutions/sigrid-software-assurance-platform/"><strong>Sigrid®</strong></a> — consist of several features. Typically, each characteristic aggregates and stores data from different sources, and calculates useful metrics, such as trends over time, libraries with the highest vulnerability risk, etc.</p><p>Then all these values are delivered to the browser, and customers can then filter, sort, and export the data to Excel and tailor it to their specific needs.</p><p>Up until now, each of our models’ characteristics had its dedicated user interface page and a single, unified “central hub” dashboard was missing from the platform.</p><p>While building this dashboard we learned a lot about how to leverage Spring Boot’s capabilities for running asynchronous workloads and how we could leverage that for this particular use case. At SIG, we believe that having the optimal data flow that minimizes response time is essential for the user experience of our products. Let’s dive in.</p><h3>Introduction</h3><p>At SIG, the majority of the tech stack for the backend teams consists of Java 17 and Spring Boot.</p><p>An essential concept for this blog post is that of concurrency. Most of our Java services code gets executed in a single thread per request, i.e., a single request from a client will usually be handled in its isolated thread. This is Spring Boot’s default model for concurrency.</p><p>Although Spring Boot can handle multiple concurrent requests thanks to the default configuration of its embedded Tomcat server, the idea is that without any additional configuration from our side, each request will be handled in a separate thread.</p><p>This workflow works very well for the vast majority of the use cases we have found so far, but when devising the new unified dashboard, we were presented with a new challenge: We wanted to be able to efficiently aggregate data from multiple different sources and backing services under a single, centralized view, so performance would become a factor in what the design of such dashboards would look like.</p><h3>Framing the technical problem</h3><p>Before diving into the approach that gave us a much higher-performing dashboard, it’s important to understand the exact technical problem and why we needed to design an optimal data-loading strategy.<br>As described earlier, the idea is to have a “central hub” style dashboard where we combine multiple characteristics of our SIG model in a single, unified view:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*x3KG79SKYHICwWRM.png" /></figure><p><em>Figure 1 — The new dashboard showcases several distinct features under a single, unified view.</em></p><p>For this post, let’s assume each card on the page is powered by a dedicated service that performs the necessary calculations and aggregations. For the example mentioned, seven distinct services need to be called to retrieve all the data for the dashboard.</p><p>Since the decision was to expose a single REST “gateway-style” endpoint call from the client, this means the following for performance when using a single thread of execution as described above:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/456/0*-JSSz6MLFk9uHoMo.png" /></figure><p><em>Figure 2 — Illustration of how the original version of the dashboard was performing its calculations.</em></p><p>As we can see in the figure above, in a single-threaded execution, the total time to complete all calculations is the sum of the time each service takes to perform its calculation. For example, if there are 7 services that each take 2 seconds to calculate, the total time to power the dashboard would be 14 seconds. However, there are ways to improve this time.</p><h3>Strategy design pattern and independent calculations — critical ingredients for the solution</h3><p>The critical aspect that steered us towards an answer to this performance issue was the fact that for each of the above calculations, the data required by each calculation was independent of each other. Thanks to this structure of our data, the Strategy Design pattern was a great fit, and by using it we took advantage of the following couple of benefits:</p><ol><li>Structuring the code in a way that lends itself to further improvements — we can add new functionality by adding new code rather than modifying existing one, which makes the process less error-prone and more efficient;</li><li>Since each calculation is independent of the others, this means that the work can be parallelized and the execution can be spanned across multiple threads running in parallel.</li></ol><h3>Using the strategy design pattern</h3><p>The Strategy pattern suggests that you take a class that does something specific in a lot of different ways and extract all of these algorithms into separate classes called strategies.</p><p>The idea is that these strategies are independent of each other and that there is a top-level context, provided by an “umbrella” class, that is responsible for triggering the execution of the right strategy at runtime.</p><p>This encapsulation is done through an interface implemented by the distinct classes, which then performs its calculations internally according to the specific strategy it implements.</p><p>In our particular case, the abstraction chosen to encode our strategies was a so-called “FeatureCalculation” interface with a method, <em>performCalculations(FeatureType) </em>which then was realized in concrete classes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/816/0*U5AdbUKbpiYjqVFa.png" /></figure><p><em>Figure 3 — Each specific feature has its implementation of a generic calculation mechanism</em></p><p>This nicely encapsulates the domain knowledge that each feature’s specific calculations are independent of each other. As a bonus, it enables us to expand the dashboard with new features in a very natural and easy manner.</p><p>This was the first part of the design that enabled the improvement we will discuss next, namely, performing each individual calculation in its thread.</p><h3>Running the calculations in parallel — leveraging asynchronous workloads with Spring Boot</h3><p>In Spring Boot, one way to implement the strategy pattern is to have a Map declared at the “umbrella” class level, which maps a particular “context” key to the interface that encapsulates the strategies.<br>At runtime, all beans implementing that interface are automatically autowired to fulfill their role.</p><p>The advantage of leveraging design patterns is that the code becomes structured so that extensions or future enhancements to it are easy to implement, one such extension being changing its technical characteristics, as we’ll explain below.</p><p>In our case, the future enhancement was that the calculations for each of these services would be performed asynchronously, so we would take advantage of the processing power that was available to us server-side and exchange it for much better performance — essentially, the total run time would go down from being the &lt;sum of each calculation&gt; to &lt;runtime of the single, longest calculation&gt;.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PeMwCn2aKmLAFnKF.png" /></figure><p><em>Figure 4 — How asynchronous execution improves performance for our dashboard</em></p><p>The idea is that instead of synchronously calling each of the `performCalculation(Feature)` methods in the main thread, which would result in a very expensive and long computation, we can offload work to distinct worker threads that can be run simultaneously, and then merge the results once they are all completed in the main thread, making the total run time that of the longest running job plus the cost of actually merging the results.</p><p>Spring Boot offers support for asynchronous programming by allowing a specific configuration class, annotated with the `@EnableAsync` annotation that implements the `AsyncConfigurer` interface, to be programmatically defined.</p><p>Our development team was already using it in a simpler form for another use case, but we decided to explore it further and see if we could use any of the additional methods available to cater to our new needs.</p><p>The `AsyncConfigurer` interface requires the configuration class to implement the method: `getAsyncExecutor()` which returns an Executor, which is, essentially, in Java terms, a hand-crafted ThreadPool executor configured with the desired parameters for your particular use case. This was where delving deeper into the framework capabilities paid off, and we could accomplish our goal of running our different “FeatureCalculation” services in parallel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rJzePaClDa1SLFL4.png" /></figure><p><em>Figure 5 — Configuration for enabling asynchronous execution on our Spring Boot application</em></p><p>The most notable aspect we will highlight here is the setting of a task decorator, here realized by a MultitenancyAwareTaskDecorator.</p><p>At a high level, setting this task decorator allows for setting the execution context around the task’s invocation, or providing some monitoring/statistics for task execution.</p><p>As a side note, this is actually the realization within the Spring Boot framework of another design pattern, appropriately called <em>Decorator.</em></p><p>The idea behind the decorator design pattern is to add new behavior to an existing object without modifying its structure. This is achieved by creating a decorator class that wraps the original object and adds new behaviors to the decorator.</p><p>In the example above, the task decorator achieves this by “decorating” the task to be executed with the decorator we provide to it. In our case, the decorator is responsible for making our tasks “multitenancy aware”.</p><p>For Sigrid’s use case, where we work with a multi-tenant setup where all the customer data is in the same database, this decorator provided exactly the right tool for the job: <strong><em>we wanted to be able to set, for the different threads, the execution context, which ensures the scope of data visible and accessible is only the one required and defined by the execution context.</em></strong></p><p>From a code perspective, this task decorator is a Spring-annotated component that implements a functional interface, TaskDecorator, that requires overriding the `Runnable decorate(@NotNull Runnable runnable)`.</p><p>This receives the parent thread as a Runnable argument and the idea is that we will return a new Runnable, which in this case will be the child thread that can then be contextually enriched with any information needed from the parent thread, allowing the child thread to run <em>with context </em>which was the key for our case.</p><p>Finally, to get the complete picture, there are only two more additional details that need to be mentioned to ensure that the setup works as expected: the methods we want to execute within the child threads must be public, so that they can be discovered by Spring via the annotations, and they must, mandatorily, return a CompletableFuture&lt;&gt; wrapper type, indicating that since the methods will be executed in child threads, they will be completed in the future, and their results will be aggregated in the main thread. An example of the signature for computing the maintainability piece would be:</p><pre><br>@Async<br>@Transactional(propagation = MANDATORY)<br>@LogTiming(parameterNames = {“featureType”})<br>public CompletableFuture&lt;OverviewTilesResponseDTO&gt; performCalculationForLicense(FeatureType f) {<br>….<br>}</pre><p>Here we add the Async annotation on top, and we see that the method returns a CompletableFuture wrapper type.</p><p>With these aspects in place correctly, the method will be executed in a separate thread, managed by the thread pool executor we saw earlier.</p><h3>Conclusion</h3><p>With this detailed view into how we have designed our new dashboard, we realized how important it is to look into your business domain to see where “seams” are that enable data separation, and then, together with using battle-tested design patterns, we were able to easily tailor a solution to our needs to implement functionality that is tenant-dependent in an asynchronous way, giving us much more maintainable code that is easier to extend and whose performance is much easier to improve.</p><p><em>Thanks to my colleague Mircea Cadariu for reviewing this blog post and providing several suggestions for improving content and clarity, and thanks to my colleague, Fabian Lockhorst, for all the development work done together to see this implementation to its completion.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=13765cec7012" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softwareimprovementgroup/improving-loading-times-of-data-rich-dashboards-with-async-workloads-in-spring-boot-13765cec7012">Improving loading times of data-rich dashboards with async workloads in Spring Boot</a> was originally published in <a href="https://medium.com/softwareimprovementgroup">Software Improvement Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Legacy Modernization at SIG: revamping our authorization system — part 2]]></title>
            <link>https://medium.com/softwareimprovementgroup/legacy-modernization-at-sig-revamping-our-authorization-system-part-2-5d2006c937b?source=rss----b58f22d3f9ab---4</link>
            <guid isPermaLink="false">https://medium.com/p/5d2006c937b</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[architectural-design]]></category>
            <category><![CDATA[decommissioning]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[legacy-modernization]]></category>
            <dc:creator><![CDATA[Bruno Oliveira]]></dc:creator>
            <pubDate>Thu, 10 Nov 2022 09:02:59 GMT</pubDate>
            <atom:updated>2022-11-10T09:02:59.175Z</atom:updated>
            <content:encoded><![CDATA[<h3>Legacy Modernization at SIG: revamping our authorization system — part 2</h3><h4>The second and last part of this blog series, where we explore how SIG completely revamped its authorization management system such that it is now managed “in-house”, as opposed to relying on a third-party software solution (Atlassian Crowd) that would not meet the immediate needs of our vision going forward.</h4><p>This is the last installment of the blog post series about <a href="https://www.softwareimprovementgroup.com/resources/legacy-modernization-at-sig-revamping-our-authorization-system-part-1/">legacy modernization at SIG</a>. In the previous post, we looked at the decommissioning from a technical perspective, the reasons we had to do the decommissioning, and how we were using Crowd at SIG.</p><p>In the second and last part of this blog series, we look at the new data model that was introduced, and how data was effectively migrated between systems. Finally, we wrap up with a look at the performance and landscape benefits this effort has brought.</p><h3>New Data Model and Storing authorization data</h3><p>When designing a new data model from scratch, especially in the case of decommissioning a legacy system, in addition to considering potential future model changes, it’s perhaps even more important to consider the minimum viable data model that can support the necessary existing use cases without over-compromising future flexibility.</p><p>In other words, try to encode in the data model <em>only </em>the necessary and sufficient data tables and constraints that will enable it to work <em>today, </em>and that make the model easier to change in the future, minimizing the number of moving parts to complicate potential future data migrations.</p><p>Going back to the previous blog post: managing authorizations involves two data model entities and a mapping table to link them together: there are users, there are portfolios, and systems (which can be seen as one entity: user groups) and then there is the relationship between these entities. In a UML-style diagram, in a very simplified way, we have the following model:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Yr8PoDfhJT-OdzWR.png" /></figure><p><em>Figure 1 — Adopted data model to cater to the new system once Crowd is removed</em></p><p>As we can see above, the new data model is as simple as it needs to be to get the job done: mapping users to the collection of their authorized access portfolios and/or systems.</p><p>There are some crucial aspects that guarantee the full backward compatibility of this new data model with Crowd.</p><p>The relationship table User_Usergroup encodes the many-to-many nature of the relationship between users and groups along with the required constraints we would expect in a model of this nature: a user must always be in at least one group, and a group can have any range of users from 0 (think, a newly created group) to many.</p><p><strong>The other very important aspect is that the group names for users would follow the conventions that were in place in Crowd.</strong></p><p>This was the aspect that really allowed a “façade” between the two systems and allowed us to have both systems coexisting while everything continued to work as intended.</p><p>With this convention in place, when both systems were used side-by-side and requested at runtime when it was needed to make an authorization decision, we could simply merge the groups from both sources into a Java set, programmatically removing duplicates and ensuring that the clients would get their access as expected.</p><p>The next decision that followed was that we would leverage our existing AWS infrastructure and create a separate database in our existing RDS instance to manage these new authorizations under the new data model.</p><p>This was a no-brainer for us, especially since we already use RDS for managing our main application DB and already have experience with it, so it was natural to use it for this as well.</p><p>From a technical perspective, this meant that with this new change, Crowd could be completely out of the picture, both for the test setup we had in place and for the real production setup, which would amount to a new setup similar to the image below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/0*sUauVJsPqzGVfSqn.png" /></figure><p><em>Figure 2 — New setup for managing Authorizations with Crowd out of the picture</em></p><p>The key point in the above setup is that now, with Crowd out of the picture, all authorizations are managed in a newly introduced RDS database which will be responsible for managing the authorizations for both SIG employees and customers.</p><p>This has the advantage of centralizing the responsibility within the scope of our infrastructure, making management, maintenance, and future changes easier.</p><p>The other very obvious benefit is the performance improvement across our landscape as a result of removing Crowd. We will dive into the specifics later on.</p><h3>Data migration from Crowd to the newly introduced database</h3><p>Now that the new infrastructure setup and data model are in place, the next step is to move the data from what we had in Crowd to the newly introduced data model and store it in the new database.</p><p>The idea is to combine several pieces of our landscape to achieve this:</p><ol><li>Connect to the Crowd API via a pre-existing Java Crowd Client implementation, living in our codebase as a standard Spring Boot component;</li><li>Through this client, we retrieve the data from Crowd and convert it to fit our new data model;</li><li>Once step 2 is done, by leveraging Hibernate and its entity representation of our DB tables, the data is “transferred” to the new Authorization DB. Note that for this step, during the actual migration process, an RDS-managed replica is used, i.e., a disposable copy of the real production database is used to ensure correctness and consistency before applying it for real.<br>The use of these replicas acts as an extra safety net before the real migration is performed;</li></ol><p>After these three steps, a sanity check is applied when the current content of Crowd matches the content in the Authorization DB.</p><p>4. After verifying the contents of both data sources and checking that everything is correct, the migration can be done for real. This means that data is retrieved from Crowd and converted to fit our new data model and then stored in our new DB.</p><p>This is done via a CLI SpringBoot application that runs on its own and exists only to migrate the Crowd data to the new data model.</p><p>Then, as detailed in part 1, once the data migration is complete, we apply the strangler architecture pattern to complete the migration process.</p><h3>Improvements post-migration</h3><p>After the migration was completed and Crowd was no longer used directly in our infrastructure, we used the nice observability capabilities of <a href="https://aws.amazon.com/xray/">AWS X-Ray</a> to verify the improvements our infrastructure has benefited from.</p><p>We can observe below in an X-Ray trace analysis how much impact Crowd had on our existing response times for some endpoints:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uvIfjNg37xSH_v_9.png" /></figure><p><em>Figure 3— The impact Crowd had on our existing response times</em></p><p>We can see how for this given request, the total time was 4.7 seconds, and we can see how a single call to Crowd took 4 seconds!</p><p>After removing Crowd, we have gained more control and flexibility over our authorization management, we have improved the performance of our SIGRID platform as a byproduct, and last but not least, we learned many valuable lessons about cross-team collaboration, expectation management, applying the right patterns for the task and considering the impact of our work at multiple levels in our landscape, from our consultants to our customers.</p><h3>Conclusion</h3><p>Implementing large-scale changes, such as decommissioning of Crowd at SIG, provides a unique opportunity to explore the limits of our platform and our engineering teams.</p><p>When availability is required and working with customer-facing features that have an impact, it becomes even more important to make trade-offs between high availability and data preservation.</p><p>We have learned that when our team is fully focused on a difficult problem like this, we are capable of delivering improved performance with little to no issues affecting customers.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d2006c937b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softwareimprovementgroup/legacy-modernization-at-sig-revamping-our-authorization-system-part-2-5d2006c937b">Legacy Modernization at SIG: revamping our authorization system — part 2</a> was originally published in <a href="https://medium.com/softwareimprovementgroup">Software Improvement Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducing Airflow at SIG]]></title>
            <link>https://medium.com/softwareimprovementgroup/introducing-airflow-at-sig-2f239c8aa146?source=rss----b58f22d3f9ab---4</link>
            <guid isPermaLink="false">https://medium.com/p/2f239c8aa146</guid>
            <category><![CDATA[airflow]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Marijn Dessens]]></dc:creator>
            <pubDate>Fri, 04 Nov 2022 07:19:09 GMT</pubDate>
            <atom:updated>2022-11-04T07:19:09.517Z</atom:updated>
            <content:encoded><![CDATA[<h4>(and some bonus thoughts on technology selection)</h4><p>This is an account of how we introduced Airflow at SIG, describing the why, the what and the how. While writing, I began to draw parallels with earlier technology selection efforts I was involved in and thought it would be interesting to make a comparison. So that’s what I did. But first, let’s look at Airflow.</p><h3>Why we needed Airflow (or something like it)</h3><p>Our marketing department might disagree, but you could say that SIG provides static code analysis as-a-service, running a little over 60.000 analyses per month. The infrastructure for that was originally built in-house dating back to 2010 and was starting to show its age. As these things go, there’s never a moment when things explode in your face but you can see the cracks getting bigger, so around 2019 we decided it was time to think about a new setup, preferably without reinventing the wheel too much.</p><p>Running static code analysis is not an on-line transaction (it’s not fast enough for that) but it’s also not a batch job (it’s triggered by new code being available, not by the clock). It’s more akin to build pipelines, so we initially looked at that type of tooling. We had experience with Gitlab CI/CD and Jenkins but didn’t think they were a great fit. Gitlab was too closely tied to individual repositories and Jenkins was not software-defined enough for our taste and we would heavily depend on plugins to get Jenkins to do what we needed.</p><h3>Gauging the market and making a decision</h3><p>Then, we turned to a more loosely defined category of ‘software that can orchestrate workflows’. There we discovered that many well-known tech companies had apparently dealt with similar issues, solved them and shared the results with the lesser gods out there. As is the etiquette, they all had tongue-in-cheek names like ‘Luigi’ (Spotify), ‘Pinball’ (Pinterest) and Conductor (Netflix). However, AirBnB’s creation (Airflow) appealed to us most. It was reasonably easy to build a PoC that strung together a couple of Docker containers and allowed data to be passed between those containers with not too much Python code.</p><p>The nice thing about making technology decisions in an organization like ours is that you can be unfair; we were not in a formal tender process or anything like that. We could get Airflow to do what we wanted and it met a set of criteria we had previously created, so we could give the competitors a quick glance-over, asking ourselves ‘Is there any way in which this product is clearly superior over Airflow?’. The outcome of that exercise could be summarized as ‘no’, so we went ahead with Airflow.</p><h3>Start small and learn</h3><p>Then came the question of where to start. You want to start in a place where you gain some experience with how the solution behaves IRL, but where you have some room to manoeuvre if things don’t go exactly as planned. Not purely coincidentally, we were introducing a new analysis type at that time that didn’t fit well in the existing infrastructure, so that was a logical place to start.</p><p>All in all, we got it to work except for one fundamental problem. The Airflow API (which was still experimental back then) did not allow us to trigger more than one analysis <strong>per second</strong>. And as we all know, in Computerland, a second is an eternity. Luckily, the problem was in the API itself and not in the core which led to <a href="https://github.com/apache/airflow/pull/6380">our only contribution to the project</a> so far.</p><p>There were a couple of other obstacles we had to overcome before we could consider ourselves happy campers. There was Airflow’s inability to mask secrets (fixed since 2.2) which forced us to tweak the UI so ‘normal’ users could not see the so-called ‘rendered templates’. Also, we needed <a href="https://github.com/teamclairvoyant/airflow-maintenance-dags/blob/master/db-cleanup/airflow-db-cleanup.py">3rd-party code</a> to do some cleaning up, as some UI elements got unresponsive with our volumes. A telltale sign there was that the numbers would no longer fit in the designated circle area when the total number of runs for some DAGs reached 100,000. Again, Airflow offers this out-of-the-box these days.</p><h3>More observations and where next</h3><p>Did we run into more things? Of course, but we managed to move our entire workload to Airflow without any major incidents or technical challenges. We had to play around a bit with weights, queues and especially pools to get everything right, but all within the confines of what Airflow offers.</p><p>Very recently, we moved to Airflow 2. We decided to combine this with a move to Kubernetes (moving away from the Docker Swarm-based deployment we were running with Airflow 1). This should allow us to scale better and leverage the work being done in the community on the k8s deployment. Our old deployment used hand-crafted Airflow images, the maintenance of which gave us no particular advantages, so we switched to the standard images.</p><p>Another area of improvement is tied to our strategy of giving users a shorter feedback loop on the quality of the code they commit, which implies that you might run more than one analysis on the same repo in parallel. Right now, Airflow does not know about this, because it does not know the concept of a repository (or ‘system’, as we call it in our data model). This sometimes leads to problems when importing analysis results in our database. So perhaps we need to teach Airflow the concept of a system to ensure things happen in the correct order.</p><p>But all in all, we’re pretty happy campers so far and we’re confident that Airflow will continue to support our scaling workloads for quite some time!</p><h3>A moment of reflection: Open Source vs. COTS</h3><p>While writing this post, I started to compare our introduction of Airflow to technology selection processes in the past in which I was involved, not as an engineering manager but as a consultant. In all cases there was a technical problem coupled with a business problem, both sufficiently well articulated. The big difference between the earlier cases and the Airflow case is the lack of a commercial aspect in the latter.</p><p>Being able to use open source software to solve a technical problem is really different from using COTS software. It allows you to focus on solving the actual problem you have, keeping it small at first and expanding the effort as your solution proves to work. This is quite a contrast with COTS software, whose implementation is inevitably top-down in nature. A vendor wants to talk to the higher ups because that’s where spending decisions are made. These higher ups will then involve project managers, buyers, HR and other stakeholders (and perhaps a bunch of consultants ;-)). These people will invariably end up in workshops listening to polished stories and sit through confusing demos. This is all well-intended, but it obscures the question: does this solve our technical problem? Many non-technical hours will have been spent before the answer to that question becomes clear.</p><p>So open source software will have a much lower cost of introduction than COTS, which adds to its attractiveness. Perhaps the picture is different when the problem is more ‘business-y’ (open source ERP is still not a big thing AFAIK) but if the technical problem is clear enough, COTS software should have very obvious advantages for me to even consider it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2f239c8aa146" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softwareimprovementgroup/introducing-airflow-at-sig-2f239c8aa146">Introducing Airflow at SIG</a> was originally published in <a href="https://medium.com/softwareimprovementgroup">Software Improvement Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Legacy Modernization at SIG: revamping our authorization system — part 1]]></title>
            <link>https://medium.com/softwareimprovementgroup/legacy-modernization-at-sig-revamping-our-authorization-system-part-1-78b93096eaff?source=rss----b58f22d3f9ab---4</link>
            <guid isPermaLink="false">https://medium.com/p/78b93096eaff</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[legacy-modernization]]></category>
            <category><![CDATA[data-migration]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Bruno Oliveira]]></dc:creator>
            <pubDate>Mon, 29 Aug 2022 08:33:46 GMT</pubDate>
            <atom:updated>2022-08-29T08:33:46.796Z</atom:updated>
            <content:encoded><![CDATA[<h3>Legacy Modernization at SIG: revamping our authorization system — part 1</h3><h4>This series of blog posts will explore how SIG completely revamped its authorization management system such that it is now managed “in-house”, as opposed to relying on a third-party software solution (Atlassian Crowd) that would not meet the immediate needs of our vision going forward.</h4><p>In part 1, we will detail how we executed this decommissioning from a technical perspective, the reasons we had to decommission its use, and we will conclude with an explanation of how Crowd was used at both testing and production setups at SIG.</p><p>In part 2, we look at the new data model that was introduced, how data was effectively migrated between systems, and finally, we wrap up with a look at the performance and landscape benefits we gained from this effort.</p><p>There will be references to Amazon Cognito, which we use as our Single Sign-On cloud-based authentication provider. While we previously used Crowd for <em>both </em>authentication and authorization, as a result of this project the situation will be different: we are delegating our authentication to Amazon Cognito and authorization will be handled in a PostgreSQL database for which the schema can evolve more easily. The latter will be the focus of this blog series.</p><h3>Introduction</h3><p>Any software company that has been in business for a long time has had to deal with what are known as Large Scale Changes (LSC) at some point.</p><p>These changes can range from code only, to staff and personnel changes, technology, or vision.</p><p>What all these changes have in common is that they require cross-team coordination (and even within a single team) over a fairly long period to ensure that they will land properly and without any outstanding issues or service degradation. The complexity of getting LSC to land properly is also affected by how the software being migrated is used in practice: it’s not a given that the consumer team will use the software being replaced as the developers who have created it intended.</p><p>Such a difference in usage introduces complexity where most time is usually spent and can be a key driver in the decision to migrate away from the original solution once the complexity of such a custom usage outweighs the benefits of using the “right tool for the job”.</p><p>Let’s dive in.</p><h3>The decommissioning from a technical perspective</h3><p>We’ll first look at how this decommissioning was performed at a technical level.</p><p>At a high level, it required moving data from the source to be decommissioned to a newly introduced one, and, for a short period, to ensure <em>both </em>data sources were in sync.</p><p>This came with several challenges, and we’re not advocating this as the “One True Way” to perform this type of data migration, this is just how we approached it after considering the risks.</p><p>One of the biggest challenges in performing this decommissioning is that, since this involves authorization data for both SIG employees and customers, absolutely nothing was allowed to be broken or temporarily unavailable, as that could result in customers no longer being able to use any functionality whatsoever, which could negatively impact us and our customers’ businesses.</p><p>Additionally, besides ensuring that nothing would break, we also wanted to be able to continue delivering new functionality while working on this legacy decommissioning project.<br>To do this, we let the question: “How can we make it so that <em>it doesn’t matter</em> when exactly the data migration happens?” guide our efforts. One advantage of this approach is that it offered us the opportunity to onboard the members of our own platform team to use it and get familiar with the new set-up as early as possible. This ensured familiarity and a smooth transition, rather than only doing this at the end when everything was already set up.</p><p>This crucial aspect led us to follow “the safe road”.</p><p>In order to minimize risk, instead of performing a large-scale change (new code + data migration in lockstep) all at once, disabling the original data source (Atlassian Crowd), we applied the so-called “<a href="https://martinfowler.com/bliki/StranglerFigApplication.html">strangler architecture pattern</a>”.</p><p>In addition to using this architecture pattern to ensure a smooth “service transition”, we also wanted to be able to work on this iteratively and validate small changes before moving on to the next one. Additionally, small changes have a small “blast radius” which makes the process safer.<br>This pattern also allowed us to shape our work in such a way that maximum parallelization was possible, which meant that different team members could work on dedicated services under the hood without running into each other’s work.</p><p>In our particular case, the strangler architecture pattern essentially allows Crowd and its replacement to coexist by abstracting access to downstream services behind what is known as a “strangler façade”: as we make the change, we keep both the old and new services side-by-side for some time, slowly migrating all dependent services to use the new one and phasing out the old one.</p><p>Finally, once all downstream services no longer use the old service, it can be removed from the codebase along with the strangler façade.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/0*FokA1V-PX8_3VYvR.png" /></figure><p><em>Figure 1 — The strangler architecture pattern</em></p><p>For our particular scenario, the way the “estrangement” manifested itself was through a one-to-one mapping between the <em>conceptual models</em> of the two services. Essentially, the concept of having the authorizations expressed by dedicated groups representing access to a given system was kept the same. (see the section on “How Crowd was used at SIG” for details)</p><p>So, while the actual data models between Crowd and our newly introduced API and DB were different, their underlying concepts remained the same.</p><p>While the migration was ongoing, groups were read from both Crowd and our new database for some time, and then all authorizations were “sanitized” by removing duplicates and ensuring consistency between both sources.</p><p>We also had an extensive set of tests covering this and preventing mistakes.</p><p>In this way, we were able to reliably carry out the migration unobtrusively “behind the scenes,” allowing our customers to keep using our platform without being aware of all the work that was happening in the background: this means that the strangler façade (enforced via data model compatibility and authorization sanitization from both sources) worked perfectly to protect downstream consumers from the effects of this change.</p><h3>Reasons for decommissioning Crowd</h3><p>There were several reasons for decommissioning Crowd, both business-related and technical, which we will briefly outline below:</p><ul><li>We wanted to allow some of our customers to use Single Sign-On to log into Sigrid. This means users can potentially use their own authentication system to log into Sigrid, which significantly improves the UX for our customers;</li><li>We wanted to add Multi-Factor Authentication, as it is one of the most common methods for secure authentication today and prevalent in modern applications;</li><li>In addition, clients began to ask for new custom authorization schemes that better suited their organization, and the Crowd-based solution did not provide the flexibility needed to implement and manage this as easily as we would have liked.</li></ul><p>We were also not using Crowd in the way it was intended: we were using it to support Sigrid, which is an externally available application that uses multi-tenancy. Crowd was not meant for external exposure or multi-tenancy.</p><p>Due to these limitations, we decided to leverage Cognito to provide SSO for our customers.</p><p>By leveraging the functionality of <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-with-identity-pools.html">Cognito’s identity pools</a>, we support not only users managed in an existing user pool but also users who authenticate with external identity providers such as Facebook, Google, Apple, or an OIDC or SAML identity provider.</p><p>As an Amazon Web Services offering, Cognito was a natural fit for us, because much of our infrastructure was (and still is) managed by AWS, so stopping depending on Crowd was a logical and natural next step.</p><p>Combined with the fact that our Crowd license was set to expire and was no longer an option for us, we found ourselves for a short period in a scenario where both Crowd and Amazon Cognito co-existed.</p><p>With the SSO setup and Crowd both in place to manage authentication and with Crowd <em>also </em>managing the authorization process, the complexity would grow to unmanageable levels.</p><p>With both mechanisms in play, the current stack would look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1VBpTD649iwX3Vtk.png" /></figure><p><em>Figure 2 — The situation where both Crowd and Amazon Cognito for SSO coexisted</em></p><p>As can be seen above, this situation added a lot of extra complexity, and it would be very hard to manage and support going forward. Since Amazon Cognito is here to stay as the preferred way to offer SSO to our clients, having Crowd handle both flows would be extremely complex from a maintenance perspective, which was a good “goal to move away from”.</p><p>The other reason, shown in Figure 1, is that by taking Crowd out of the picture, we would gain a lot of ‘free performance’ <strong>because we didn’t have to make the round-trip to Crowd</strong> to retrieve authorizations on every request: with Crowd out of the picture, performance would automatically improve by replacing a component that was a bottleneck with one that is faster and over which we have full control. <strong>It’s also important to note that the Crowd round-trip would add about 3 to 4 seconds to every single request.</strong></p><p>Now that we have detailed the decommissioning of Crowd from a technical perspective and outlined the reasons why we needed to do it, we’ll now show how we used Crowd at SIG.</p><h3>How Crowd was used at SIG</h3><p>External customers and employees have access to a single system or at a customer level, which can be considered a set of related systems.</p><p>So, as a general example, let’s assume we have a Portfolio, ‘sig’, which contains three systems 1, 2, and 3, which are systems representing specific parts of the internal SIG software landscape.</p><p>Out of these three systems, number 1 is considered critical, and as a consequence, not all developers can access it, let’s say, only admin users have access.</p><p>The way we used Crowd to manage authorizations is as follows:</p><p>Crowd has the top-level concept of <em>a directory </em>that contains authentication and authorization information about users and groups. Crowd supports an unlimited number of directories. Administrators can use different directories to create silos of users.</p><p>The directory is associated with an application and the relevant groups get created in the specified directory. In the generic example above, the groups would be:</p><p>‘sig-system1’, ‘sig-system2’, and ‘sig-system3’.</p><p>These would represent authorizations for systems ‘system1’, ‘system2’, and ‘system3’ of ‘sig’.</p><p>In terms of integration with our codebase, the use of Crowd predominated, both in our production and testing setup.</p><h4>Crowd as part of our production setup</h4><p>The basic flow when a request reaches our back-end is a combination of responsibilities between the Spring Security filter chain and Crowd to decide whether a user is authorized to access a specific resource.</p><p>In our chain is a dedicated filter whose sole purpose is to contact Crowd to retrieve what is defined as a “list of groups”. These groups encode the authorizations for a particular user and will determine whether access is granted.</p><p>The diagram below provides a high-level overview of our production setup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dHd9Mklgm38TGoU-.png" /></figure><p><em>Figure 3 — Simplified setup of how Crowd fits in our production setup</em></p><p>An important detail is that when using a user’s information to contact Crowd, the group sets will be scoped by a combination of user details and the portfolio for which access is requested: SIG employees are located within a specific Crowd application that could be called “SIG”. Within this directory, we would have the relevant permissions to individual portfolios and within each portfolio, there would be several systems with a list of users who are allowed access to them.</p><p>Continuing with the above example, I would not be placed within the group “sig-system1” because I would not have access to it.</p><p>As a result, the Crowd call would not grant me access to that system, and I would not be able to access it.</p><p>This is how our production setup is done at a very high level. Let’s look at the impact of Crowd on testing.</p><h4>Crowd as part of our test setup</h4><p>In addition to the production setup, to test and validate the correct access to our endpoints by different customers, as well as validate how the UI configuration and messages would look, we needed a way to embed Crowd into our integration tests to ensure that access control was kept as intended when adding new endpoints and/or modifying existing ones.</p><p>As discussed in our previous article about how we do <a href="https://www.softwareimprovementgroup.com/resources/cicd-best-practices/">CI/CD at SIG</a>, we use Docker to isolate and easily leverage our dependencies in different environments, such as the dedicated back-end or front-end integration testing.</p><p>As part of our test setup, a very bare-bones Crowd server was emulated and exposed to our test environment via a dockerized Mountebank setup.</p><p>The basic idea is to simulate the possible combinations of authorizations for a specific set of test systems that can be used to validate both the correct authorization enforcement and the actual underlying implementation for different types of users. An external user should not have access to internal SIG systems, while a special test user can have broader access as it is only used within the context of these integration tests, for example.</p><p>The way we found to encode these different permissions is shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*h7xdA3h_3jyZ8X6v.png" /></figure><p><em>Figure 4 — How we mocked and used Crowd in our testing setup.</em></p><p>To conclude, there may be differences in the JS mountebank configuration files between the back-end and front-end for different testing scenarios. The front-end needs to be much more thorough with permissions to validate rendering of, for example, error messages, pop-ups, and other things, while the back-end is, strictly speaking, only interested in a particular response code and/or body depending on the type of API endpoints being implemented.</p><h3>Conclusion</h3><p>In this first post on legacy modernization at SIG, we looked at how we performed the decommissioning of Atlassian Crowd from a technical point of view, outlining together with it, the technical and business-related reasons to do so.</p><p>Then we also briefly looked at how we were using it at SIG to give some additional context to the actual decommissioning.</p><p>In the next blog post, we will look at the newly introduced data model that was used to support the migration, we will look at exactly how the migration of the data was done, and, lastly, we will look at some benchmarks that detail the performance gains we have achieved.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=78b93096eaff" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softwareimprovementgroup/legacy-modernization-at-sig-revamping-our-authorization-system-part-1-78b93096eaff">Legacy Modernization at SIG: revamping our authorization system — part 1</a> was originally published in <a href="https://medium.com/softwareimprovementgroup">Software Improvement Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How we do code reviews at SIG]]></title>
            <link>https://medium.com/softwareimprovementgroup/how-we-do-code-reviews-at-sig-6e5189fb1e6c?source=rss----b58f22d3f9ab---4</link>
            <guid isPermaLink="false">https://medium.com/p/6e5189fb1e6c</guid>
            <category><![CDATA[quality]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[code-review]]></category>
            <dc:creator><![CDATA[Bruno Oliveira]]></dc:creator>
            <pubDate>Wed, 13 Apr 2022 13:55:12 GMT</pubDate>
            <atom:updated>2022-04-13T13:55:12.431Z</atom:updated>
            <content:encoded><![CDATA[<p>Every team works in different ways, and the way in which teams do code reviews is no exception.</p><p>This is because there’s not a universally agreed-upon way of doing effective code reviews, so while the specifics of each team’s process might be different, the underlying motivations to actually perform code reviews are the same.</p><p>We will see what the motivations are behind code reviews, how they manifest in practice, how they fit into the normal workflow for developers, and, finally, we will detail their most important aspects and how that process is conducted at SIG.</p><h3>Code reviews: why to do them</h3><p>Code reviews serve various purposes, some of more technical nature, others more closely tied to the human and teamwork factor of writing code.</p><p>By making sure that every PR is a team effort, the responsibility is shared between the person who wrote the code and the person who is responsible for reviewing it, which means that every change will be reviewed and approved by <em>at least </em>two people. As stated by Eric Raymond: “given enough eyeballs all bugs are shallow”. Besides this there are other positive implications for the overall codebase health:</p><ul><li><strong>A consensus must be established between writer and reviewer:</strong> this means that the code will be less likely to be written in a very particular or personal style and will be more likely to follow existing patterns in the codebase;</li><li><strong>Consistency across the codebase:</strong> over time, the codebase can grow in both size and complexity, so some abstractions might not be on the author’s radar. A review done by a more knowledgeable colleague can help in maintaining consistency and prevents us from “reinventing the wheel”; it also helps to ensure the overall quality of the codebase.</li><li><strong>Knowledge sharing:</strong> reviewing code is a great way to guarantee knowledge sharing because while some areas of the codebase will be very familiar to some people, there will be other aspects of the codebase that will be unknown. By doing code reviews people can be exposed to areas that they wouldn’t otherwise, which increases familiarity, increasing the whole project’s <a href="https://en.wikipedia.org/wiki/Bus_factor"><strong>bus factor</strong></a>;</li><li><strong>Fresh perspective:</strong> when you are too deep into technical work, it’s easy to lose sight of the bigger picture or forget an important detail that is critical for the correct implementation of a given feature. Having a person who is detached from the actual work looking at the code provides a much needed new perspective that can be crucial to assess both the <strong>correctness </strong>and the <strong>completeness </strong>of the work;</li></ul><p>By guaranteeing the correctness and completeness of the implementation, as well as additional non-functional requirements, like test coverage not dropping and no regressions being introduced, we can guarantee via a team effort that the quality of the new code being written is up to the standards of the existing code.</p><p>Obviously, when there is a deliberate effort to maintain quality, the maintainability improves as a result and the code is easier to maintain, extend and reason about.</p><p>Another very important benefit, albeit less tangible, is that it signals to new developers joining the team that quality is at the forefront and taken seriously. It makes them more aware of these aspects so they can quickly level up to the high-quality standards that the team holds itself against; aka code must be at 4 stars, indicating that its quality is above the industry average and signaling to other developers that the code is easy to maintain and extend.</p><h3>Anatomy of a code review: how to do it and what to look for</h3><p>The main focus of a code review is a process of (usually) asynchronous collaboration between the reviewer and the person who wrote the code. The reviewer will go over the changes put up for review and, by following a structured approach that is usually a combination of the industry’s best practices as well as the specific practices within your team or organization, will create small comments that need to be discussed between both parties and potentially resolved either by changing the code or reaching an agreement until no new comments are added.</p><p>Once the PR has been reviewed and an agreement has been reached, the code can then be merged into production. But what exactly is addressed during a code review?</p><p>The process at SIG usually is a mix of addressing both high-level concerns about the business logic as well as enforcing code style, structure, and conventions in such a way that when all comments have been addressed, the PR is deemed to be both functionally and non-functionally correct, complete and in line with the existing codebase.<br>This review process, while not (always) fully structured, is a very efficient one in flushing out critical issues with the PR with respect to the business domain as well as performance, maintainability, consistency, readability, reliability, and security.</p><p>Each company and team can use their own set of tools and processes to conduct a code review, but at SIG we rely on Gitlab to assign reviewers, start discussions on a merge request, and then the review is done directly in the browser, via the Gitlab UI. This approach enables us to manage the code, merge requests, branches, and code review processes in a centralized location which increases developer efficiency.</p><p>A very insightful view on the importance of looking at several different levels of abstraction in a code review can be seen in the <em>test review pyramid </em>below, which we have recently adopted as part of our process:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vIU0NxZD5Sh2KDBd.png" /></figure><p><em>References: Gunnar Morling, </em><a href="https://www.morling.dev/blog/the-code-review-pyramid/"><em>https://www.morling.dev/blog/the-code-review-pyramid/</em></a></p><p>We can see that both API and implementation semantics, i.e. verifying that the actual implementation of a given ticket follows the correct business logic and behaves as intended, is where most of the efforts must be placed, as these are usually the more tricky parts to get right and, as such, the part that is most important to have reviewed by colleagues with more domain knowledge.</p><p>As for tests and code style, these aspects, while important, can be largely automated, and we do that at SIG by having a <a href="https://www.softwareimprovementgroup.com/resources/cicd-best-practices/"><strong>CI/CD pipeline</strong></a> in place.</p><h3>Code review @ SIG — a snapshot of how it’s done</h3><p>As described earlier, we use Gitlab to conduct our code review process. Look at this screenshot of a code review in the Gitlab UI below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*V5620ssakXNjgvmh.png" /></figure><p>We can see there is an assignee — the person responsible for producing the work that will be the actual merge request, and an assigned reviewer which is the person responsible for performing the review.</p><p>We can also see the ongoing discussion directly in the Gitlab UI with some considerations from both people, and the most important aspect is to always keep interactions friendly and focused on constructive criticism so that both the author and the reviewer get the most out of it.</p><p>Once an agreement has been reached, the unresolved review thread can be marked as resolved, and afterward, the work can be merged into production once the reviewer approves it. Note that we require at least one person besides the author of the changes to approve them to ensure that the review process is strictly followed.</p><p>It’s also important to mention that not all merge requests are equally impactful or critical. The difference in experience between the author and reviewer can range from significant to none, and, as such, we adapt our code review process by adhering to the following guidelines:</p><ul><li>If the author is experienced, it makes sense for the author to merge their own changes, as they have the most knowledge and are best suited to time the merge and see the changes through (e.g. when a migration comes into play), after approval of the reviewer.</li><li>If a change is trivial (e.g. typo’s in the documentation) or is done by someone outside of the maintaining team, the reviewer can merge after approving themselves.</li><li>If the author is less experienced and the reviewer is worried about the merge, they can always start a thread to indicate a branch cannot be merged yet with an explanation, or just not approve it yet.</li><li>It is always encouraged to bring a merge request up in the SUM before merging, just to identify any blockers and raise awareness of upcoming changes.</li></ul><p>We consider a certain merge request to be reviewed after the reviewer approves the merge request, which for us it’s done via the UI of Gitlab.</p><p>One particularly interesting aspect of the code review process at SIG is how we leverage our own tooling to aid us in code reviews. Specifically, we run <a href="https://github.com/Software-Improvement-Group/sigridci"><strong>Sigrid CI</strong></a> in our own pipelines, which allows us to use our own models to ensure that the code that is being reviewed and written conforms to the same quality standards that we uphold our customers to.</p><p>As a nice example, after extending the functionality of a given class we had code that looked okay when reviewed in isolation within the context of the existing merge request, but our own Sigrid CI pointed out that we had inadvertently introduced a small duplication with code from a different, untouched package. This allowed the author of the merge request to refactor the code such that both call sites now leveraged a call to a centralized location accessible from a common package. So, not only the quality of the code within the context of a given merge request is looked at, but also the quality of the project as a whole.</p><h3>Future work</h3><p>As a plan for the future, as our team keeps growing, we are considering looking into tools that can be hooked up to our own build pipelines with as little configuration as possible, so they can run by default. This will increase the assurance of safety and correctness of our code and prevent a whole class of bugs from making their way past the build pipeline.</p><p>At SIG, we are fans of relying on our own tools for improving our own workflows, and just as we have adopted Sigrid CI internally before releasing it to the general public, we will keep “dogfooding” by improving and using our own tools as means to improve our code reviews.</p><p>Since our stack within the backend team is mostly Java-based, we are considering looking into tools such as <a href="https://errorprone.info/"><strong>Errorprone</strong></a> in the future.</p><p>Obviously, code reviews are based on collaboration between people, and often interpersonal conflicts can arise during this process. While these conflicts, when left unattended, can hinder the process and affect the team’s cohesion and morale when managed properly, they can actually empower teams and individuals to become better, as seen in <a href="https://arxiv.org/abs/2201.05425"><strong>this research</strong></a> paper.</p><p>There’s also <a href="https://arxiv.org/abs/2202.04586"><strong>research</strong></a> worth reading about ensuring that specific aspects of software development are addressed with intent, like an extra focus on security vulnerabilities during a review increasing the likelihood of such vulnerabilities being found early.</p><h3>Conclusion</h3><p>We looked at the role that code reviews play in ensuring that code quality is at the forefront of the work done by any software development team, and, in particular, we took a deep dive into how we approach this process at SIG, namely by relying on GitLab for all the work related to both merge requests, creating branches, creating pull requests and both start as well as tracking and signing off on a code review.</p><p>We showcased a recent concept that surfaced in the software development scene, the <em>code review pyramid, </em>and how it showcases which software development aspects are more important to focus on during the process of reviewing code.</p><p>Finally, there are also <a href="https://www.raycast.com/blog/no-code-reviews-by-default/"><strong>other companies</strong></a> where code reviews are not done at all, and reviews are done on a more ad-hoc basis, only when deemed necessary which is a nice interesting contrast to read about.</p><p><em>Thanks to my colleague Mircea Cadariu for reviewing this post and suggesting improvements with respect to our future work and regarding which aspects are important for our team when actually performing code reviews.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e5189fb1e6c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softwareimprovementgroup/how-we-do-code-reviews-at-sig-6e5189fb1e6c">How we do code reviews at SIG</a> was originally published in <a href="https://medium.com/softwareimprovementgroup">Software Improvement Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[On-demand deployment environments with K8s at SIG]]></title>
            <link>https://medium.com/softwareimprovementgroup/on-demand-deployment-environments-with-k8s-at-sig-8915bcf5af88?source=rss----b58f22d3f9ab---4</link>
            <guid isPermaLink="false">https://medium.com/p/8915bcf5af88</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Bruno Oliveira]]></dc:creator>
            <pubDate>Mon, 14 Mar 2022 12:46:49 GMT</pubDate>
            <atom:updated>2022-03-14T12:46:49.569Z</atom:updated>
            <content:encoded><![CDATA[<p>At SIG, following the industry best practices that we recommend to our customers is something we find very important because it embodies the values that we consider important for crafting high-quality software and it shows that we care about and follow our own recommendations.</p><p>One of those best practices is the robustness of the test setups for soon-to-be production code, i.e. code that will be merged into production needs to be thoroughly tested at several different levels: unit, integration, and end-to-end.</p><p>Thanks to the complexity of modern software development, from both a code and tooling perspective as well as the complexity of the domains for which code is being written to solve business problems, a new aspect of testing is gaining traction. I personally like to name it <em>branch testing.</em></p><p>The idea behind branch testing is to create an ephemeral, throw-away environment that spins up a copy of the production application being served to clients. The main difference is the code that’s being deployed is not the <em>latest </em>or <em>production, </em>but instead a branch containing a new feature, a bug fix, a performance improvement or anything else that we are interested in validating before deploying to production.</p><p>We will see how we work with these on-demand environments and how we do branch deployments at SIG.</p><h3>On-demand environments at SIG</h3><p>Having and using on-demand environments has been enabled in modern workflows thanks to Docker and Kubernetes. They make it easy to create isolated packages of everything our application requires to run in isolation. The docker images will bundle all our code and its associated dependencies. Leveraging a Kubernetes cluster, we can deploy those docker images containing our containerized code and run it in such a way that we can expose it to our company’s internal network, effectively generating an accessible URL where our entire application gets deployed and is available for testing by our colleagues.</p><p>The database used as the base for this deployment is a production replica — essentially a throw-away copy of our entire production database via a backup done with AWS. The idea behind these “on-demand environments” is to hook up this database replica into our containerized setup. Once we start our application from our Kubernetes cluster, we’ll be running a full copy of our production application codewise. The provisioned infrastructure will differ since this will be our Kubernetes cluster which we manage with EKS, not our production setup.</p><h3>Configuring on-demand environments at SIG</h3><p>The way we configure “on-demand environments” at SIG consists of applying a Kubernetes deployment to an already provisioned EKS cluster following a semi-automated process.</p><p>When creating an on-demand deployment, the only requirements are:</p><ul><li>the branch name containing the code to deploy,</li><li>the credentials and URL of the database replica from AWS, and</li><li>a defined set of values (usually the ones corresponding to the current production deployment) for all other services needed to spin up our complete application.</li></ul><p>All of these values are added in a `deployment.properties` file that is added to your repository gitignore file so it doesn’t end up in version control. The reason is that this file is dynamically generated with every new deployment we make.</p><p>Once that’s done, we run the `mvn deploy` command which will create the Kubernetes deployment Yaml file programmatically using the `cdk8s` library.</p><p>This enables developers to define in code (in the programming languages they are most familiar with like Typescript, JavaScript, Python, Java, and Go) all the necessary Kubernetes resources, like Services, Deployment, Ingresses, etc. All without the need to write Yaml files manually. It’s like an extension of your day-to-day programming language that allows you to define Kubernetes deployments without requiring you to manage YAML files manually.</p><p>For many developers who are not familiar with infrastructure-as-code, writing YAML files manually to configure all the services that will be running on the cluster is error-prone, and time-consuming.</p><p>For the use case of having on-demand environments readily available to be used, a helm chart is not necessary since these environments are very short-lived and essentially ephemeral, avoiding the need for managing them with Helm.</p><p>Afterwards, the deployment can be applied to the cluster by running the `mvn deploy` goal as cdk8s hooks into Maven’s deployment plugin.</p><p>This command will execute the programmatically-specified deployment against the cluster, which will, in our particular case, create a new namespace and provision and spin up all the associated resources in that namespace needed to start our “on-demand” application.</p><p>Using Kubernetes namespaces, we can ensure that multiple developers can spin up several application instances without conflicting with each other since these user-defined namespaces isolate resources within the cluster. As a development team, this enables us to test significant changes “in production” and in parallel without any bottlenecks, which are very valuable because they allow us to move fast and with confidence in our work.</p><p>When we finish testing our changes, we can just run `kubectl delete -f &lt;name_of_yaml_file&gt;.yml` to remove associated resources from the cluster freeing up resources for other developers!</p><h3>Using cdk8s to configure a Kubernetes deployment with code</h3><p>To use <a href="https://cdk8s.io/">cdk8s</a> in your project, make sure to add the necessary maven dependencies to your project so that the library is picked up correctly in your project. Once that’s done, you can follow the example on the <a href="https://cdk8s.io/docs/latest/getting-started">setup</a> page on the official website and get started from there.</p><p>At SIG, we use a custom setup on top of the existing functionality provided by the library, which allows us to configure our services in a declarative way.</p><p>We have a configuration class, `Configuration`, that reads all the property values from the property file mentioned above and loads them into Java to link them together at runtime to create our Kubernetes Yaml file.</p><p>Besides this class, we define an abstract class, called `WebService` defined as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YtoEplvwnjOSU9u1" /></figure><p>We use this base class to define our specific service details in code by extending from it.</p><p>The details for the name, image, ports, and environment variables are all service-specific.</p><p>However, it’s very important to notice that the namespace value and the cdk8s Charts are globally defined per deployment.</p><p>A cdk8s Chart is a base class from the library that serves as a container class for all the services that will form our final complete deployment in code. We define the Main class which contains the definitions of all the services that we want to provision in our cluster.</p><p>After that, we define an App instance, which we call the `synth` command, and will generate the final Kubernetes deployment Yaml file from this code specification. Note that the `synth` command is specific from the ck8s library, but we can also generate this deployment file by running the `mvn package` goal.</p><p>By leveraging the tight integration between cdk8s and maven’s deployment plugin, we can generate the Kubernetes deployment specification by running a maven command which is very similar to existing workflows, making it easy for new developers to be up to speed with this process.</p><h3>Observability and usability of our implementation of “on-demand environments”</h3><p>One of the biggest challenges that teams face when adopting custom solutions, like the one we described here for creating on-demand environments, is that everything feels very barebone. There are some rough edges for usability and accessibility that are fine for experimentation while our solution is gaining traction. However, it can be harmful to bringing new developers into the fold in the long run.</p><p>Fortunately, setting up simple tools to improve the user experience and increase observability is relatively easy within the Kubernetes ecosystem, and we will look at three tools here.</p><p>The first one is the capability of auto-completion for Kubernetes commands. As an example, when typing `kubectl get p` and then hitting Tab, we would be able to see the following listing:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OIe1LKHMJEuNw7d0" /></figure><p>This can be especially useful for listing namespaces or seeing resources at a glance when the setup starts growing.</p><p>To set this up, we can leverage an official script available <a href="https://kubernetes.io/docs/tasks/tools/included/">here</a>, where we have detailed instructions on setting up this script on our preferred shell environment to be provided with these very useful auto-complete capabilities.</p><p>Once you configure your shell by editing its corresponding configuration file (e.g. bashrc or zshrc, for bash or zsh, respectively) and restart your terminal, you will have the Kubernetes commands auto-completion enabled. It’s a low-effort, high-gain solution that we definitely can recommend.</p><p>The second tool is called <a href="https://k9scli.io/">k9s</a>, and this is a fantastic tool for cluster management and observability that significantly improves the overall Kubernetes experience.</p><p>In order to configure it, some extra work is required, but it is well worth the extra effort.</p><p>You can follow the installation instructions for the tool <a href="https://k9scli.io/topics/install/">here</a>, and once you run the command `k9s`, in your terminal, you will be presented with:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FzaHZb8bUkW1RiAC" /></figure><p>From this top-level dashboard view, you can see different deployments, namespaces, check for logs, filter out information you need with regex, and even look into the YAML description of your cluster objects.</p><p>It makes it a lot easier to grep for logs and look at a glance into the several namespaces currently available in the cluster, which can be great to align with colleagues and ensure that cluster management is in reach for everyone using the cluster.</p><p>Furthermore, logs can be configured to be seen at specific intervals. Capabilities like auto-scrolling, searching, and much more are a nice upgrade over the more native experience of interacting with the cluster solely via the kubectl command.</p><p>It’s a very useful tool to check if you are using Kubernetes clusters or planning to do so.</p><p>And last but not least, we can actually rely on our own IDEs when it comes to supporting Kubernetes integration. IntelliJ IDEA has a plugin for Kubernetes that can be installed and gives you access to a lot of what we have covered here, all while staying within the comfort of your own IDE.</p><p>After installing the plugin for Kubernetes, IntelliJ will automatically detect any cluster configuration you have in your local machine, (for example via the `.kubeconfig` file) and the context for that particular cluster will be available from within the `Services` tab in the IDE:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/0*89VCFFmLnt3HJ-S3" /></figure><p>Here we can see the status of the cluster we are currently working with, and under the `Workloads` tab we can see our resources like Pods, Deployments, Jobs, etc.</p><p>This facilitates the management of our cluster as well as its overview because all our resources are within one single place, which is a lot easier to manage!</p><p>Finally, a worthy note to wrap it up. There are context menus available at right-click for most of these resources and they allow us to see logs, follow them, see namespaces, and more:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/818/0*Zv1tEMXDj8o8X4pJ" /></figure><p>With these context menus at your disposal, you can actually switch namespaces, tail logs, and remove resources using the IDE directly which is a great way to have an overview of the state of your cluster while manipulating it with familiar tools.</p><h3>Conclusion</h3><p>Hopefully, after reading about our own experience about how we leverage Kubernetes to provide our developers with an “on-demand production environment”, you are now also sold on its usefulness, are willing to experiment with it and come up with novel approaches to set up your own environments to enable your teams to move faster more confidently.</p><p>At SIG, we are always experimenting with new technologies and are actively maturing our Kubernetes ecosystem.</p><p>While the road is bumpy, if you and your developers invest in it, it is possible to create custom solutions to fit your development workflows and company culture to leverage Kubernetes to empower your developers to work on new features with more confidence and move faster.</p><p><em>Note: Special thanks to my colleague </em><a href="/service/mailto:f.lockhorst@sig.eu"><em>Fabian Lockhorst</em></a><em> for the review of the blog post while it was being written and for the insightful comments to complete the section about the observability of Kubernetes clusters for our on-demand environments.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8915bcf5af88" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softwareimprovementgroup/on-demand-deployment-environments-with-k8s-at-sig-8915bcf5af88">On-demand deployment environments with K8s at SIG</a> was originally published in <a href="https://medium.com/softwareimprovementgroup">Software Improvement Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CI/CD best practices: How to set up your pipeline]]></title>
            <link>https://medium.com/softwareimprovementgroup/ci-cd-best-practices-how-to-set-up-your-pipeline-4643eea14bfa?source=rss----b58f22d3f9ab---4</link>
            <guid isPermaLink="false">https://medium.com/p/4643eea14bfa</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[pipeline]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Bruno Oliveira]]></dc:creator>
            <pubDate>Wed, 05 Jan 2022 14:52:38 GMT</pubDate>
            <atom:updated>2022-01-05T14:52:38.928Z</atom:updated>
            <content:encoded><![CDATA[<p>As a software developer at Software Improvement Group (SIG), I’ve joined the Sigrid team recently, and I have witnessed first-hand how an efficient infrastructure and a team that follows the best practices in terms of development can help you grow individually as a developer while facilitating your first contributions.</p><p>I will describe our internal process at the software development team while working in <a href="https://www.softwareimprovementgroup.com/solutions/sigrid-software-assurance-platform/"><strong>Sigrid, SIG’s software assurance platform,</strong></a> we build and maintain ourselves; how we work together by leveraging modern tools and processes to deliver relevant features to our customers reliably and quickly. It’s a great feeling to get almost instant feedback on your work, and working in a team fosters this habit. In addition, this way of working keeps me motivated to improve our code, our processes, and my peers, all with the ultimate goal of improving our product and giving our customers the best platform they can get.</p><p>At SIG, we strive for a healthier digital world, and that starts with following best practices when it comes to writing code and enabling our clients to do the same. I’ll show you how we do CI/CD, how it helps to shape a responsibility of built-in quality within our software development team, and how it creates a healthy, high-performance environment for developers as a result.</p><h3>Developing software at Software Improvement Group</h3><p>Setting up a pipeline that enables CI/CD starts at the code architecture level. Specific architectures lend themselves easily to benefit from CI/CD, while others need profound architectural changes to start implementing best practices. Here’s an example. An architecture geared towards microservices and where the main building blocks are loosely coupled makes it easier to test and develop modules in isolation, making it much easier to apply the CI/CD principles. That is as opposed to a much more rigid structure where components have very high coupling, so it’s much harder to test things in isolation, making it hard to have a solid foundation to benefit from these principles.</p><p>At SIG, we work in an architecture that easily benefits from CI/CD and is built to do so in that manner from the ground up.</p><p>We use Java, Springboot, Maven, Hibernate, Airflow, and Docker as our main development tools, which allows us to set up a comprehensive pipeline. In addition, it gives us the confidence that our code works correctly and will keep working correctly when we make changes. The ability to get immediate feedback on every commit we make is the key that allows us to move fast and with confidence.</p><p>I’ll show you how we set up a CI/CD pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bmPssT6KoAt6v5t3AxbKsQ.jpeg" /></figure><h3>Stage 1: Build</h3><p>The first stage of our pipeline is the build stage. This step is where the code is compiled, unit tests are executed, and Docker images are built from the freshly compiled code and pushed to our docker registry. Of course, when we push code to our registry, the docker images will be tagged differently, depending on if we are compiling a feature branch or if the code was merged to the main branch and is about to be released to production.</p><p>A common practice here is to tag the docker images appropriately. Either with the `latest` tag, if it’s a pipeline running against the main branch and thus ready to go live into production, or with the feature branch name if it’s a side branch where a feature is built or a bug is fixed. This ensures that the latest version of the code is always available for local testing and comparison with the newest version available to customers. This is very useful in case of bug fixes or <a href="https://www.softwareimprovementgroup.com/resources/6-things-to-consider-when-building-an-api/"><strong>API</strong></a> changes requiring verification.</p><p>Also, a test data image is created for our front-end team to use to develop better the UI against a realistic dataset which gives a lot of flexibility to both teams.</p><p>It also has the added benefit that the development team faces very little to no friction when it comes to releasing new code, and at the same time, performing maintenance work or development of new features. Every commit will generate releases according to the branch against where it was performed, and developers will have independent docker images being built without interfering with each other. It’s an essential feature of a good CI/CD pipeline, and it empowers teams to work in independent sub-teams that can move fast and work on several development tasks in parallel, fostering a highly productive environment.</p><h3>Stage 2: Integration</h3><p>The integration stage is typically where integration tests (and other pipeline tasks, for example, dependency checks to assess if our code dependencies are up-to-date or not) are executed. At this stage, having a good structure in place can make a big difference in the efficiency of your pipelines. From our own experience, we observe the following:</p><ul><li>The tests need to be reproducible, meaningful, and fast</li><li>Relevant test data needs to be available for the tests</li><li>It must be easy to add new tests to cover new features</li><li>Tests must be independent of each other’s state</li></ul><p>An important aspect is ensuring that relevant test data is available for the tests. How do we do that? We take a couple of representative systems internally and dockerize them in a database dedicated container. This way, when testing our API endpoints, we effectively can test the various flows and scenarios just like they would be “exercised” when being used by actual customers. Furthermore, it gives us the added assurance that, if our pipelines succeed, there is a very high probability that the production code will work as expected for multiple scenarios.</p><h4>Leveraging Testcontainers to speed up pipelines</h4><p>At SIG, we use the Testcontainers library to ensure that tests are reproducible and as independent of each other as possible. This allows us to pull in the relevant Docker images in our tests and easily integrate them with Springboot. Like this, we can use Docker across our entire pipelines from development to production, which is great for consistency.</p><p>However, over time, we realized that this setup had its drawbacks. In our case, the cost started manifesting itself in an increase in pipeline execution time that was becoming too high and prevented us from keeping our agility. As our codebase grew, so did the number of tests leveraging Testcontainers, making our pipelines longer and longer. If we let the situation stay as it was, we would need more machines to distribute the load and keep the execution times under control, or we could dig deeper into Testcontainers and see whether we could gain something by adapting this framework to our needs.</p><p>We noticed that we had a lot of integration tests that were retrieving data, never changing the containers during runtime, while others were mutating the data. That meant that those forcibly needed to be recreated for every test of a similar nature.</p><p>It felt like we were onto something! There was a clear distinction on our integration tests, which we weren’t exploiting their statefulness fully. If we would bundle together tests that do not mutate data and separate those from the tests that do, we can leverage the capability of Testcontainers to reuse the containers throughout the tests, reducing our pipeline execution times considerably.</p><p>To do this at a technical level, the solution was to introduce two distinct top-level classes for our integration tests: we created a MutableEndpointsTestBase class and an ImmutableEndpointsTestBase class.</p><p>The main difference between these two classes is that the Immutable one sets the boolean flag from the testcontainer variable, the `withReuse(boolean)` flag to be true, causing the same image to be reused throughout the tests who inherit from this base class, significantly improving our pipeline execution times, without any additional changes on the surrounding infrastructure needed. This results in a significant speed gain for tests that are “immutable”, and it allows us to leverage Docker’s full potential for integration tests.</p><p>We leverage Spring RESTDocs that allows us always to keep up-to-date documentation that is programmatically generated, so the overhead for developers is minimal, and the benefits for other stakeholders are much more significant.</p><p>For cases of onboarding <a href="https://careers.sig.eu/"><strong>new developers to the team</strong></a> or extending our set of existing APIs, our architecture is created so that covering new code with tests is as simple as extending from base classes that encapsulate the common services and writing our custom code for the new service. Modularity and reusability for test code are essential when doing CI/CD.</p><h4>Unit testing our code architecture with ArchUnit</h4><p>New developers are also quickly brought up to speed with our standards, as we have ArchUnit tests in place. ArchUnit essentially allows us to codify “our architectural principles” into code in a way that, for example, when a developer who is unfamiliar with the codebase adds a Service in the wrong place or references a repository class from a resource class directly, the pipeline will fail and alert the developer that the code does not conform to the architectural standards in place. These tests go to the detailed level of warning for the presence of specific annotations on certain classes, which is a highly detailed overview of the architecture we use. It fosters new developers to become better developers by learning about architecture as they do their regular work, which is something not many teams can relate to.</p><h3>Stage 3: Release</h3><p>After the compilation and successful execution of tests, the pipeline’s final stage is the production release. This stage also happens in an automated way where the newly released Docker images are picked up by Puppet after merging code to the main branch and after the pipeline passes. The services with the corresponding underlying images get automatically updated at regular, fixed intervals.</p><p>This is the Continuous Delivery aspect at SIG: a change that gets successfully merged to the main branch will automatically be deployed and visible to customers and other stakeholders without any necessary manual intervention from the developers. It helps build confidence and reliability in the team to move fast and efficiently.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Hgj-H1_hrhWTQVj-.jpeg" /></figure><h3>Conclusion</h3><p>To build an efficient CI/CD pipeline requires dedicated effort and code architecture, but this is possible to achieve when you follow these guidelines:</p><ul><li>Have an architecture that favors independent modules and contains functionality that naturally lends itself to testing.</li><li>Use containers, namely Docker, and utilities like Testcontainers to ensure that your tests are reproducible and easy to extend, and it also allows for very flexible testing data to be used.</li><li>Always keep reusability and modularity in mind when writing your test code.</li><li>Leverage modern frameworks when available for your current tech stack to reap the benefits: JUnit, Springboot, and other foundational frameworks are great blocks to build upon it.</li></ul><h3>To be continued</h3><p>Maintaining a CI/CD pipeline aligned with your company’s vision and software development and delivery goals is a continuous process that never finishes. As your company changes, grows and adapts to market trends, it’s also necessary to ensure that the setup in place can adapt itself to these external changes to keep delivering its value.</p><p>To keep updated with modern CI/CD practices, we are now looking to leverage Kubernetes to stay in the frontline of new ways to deploy code. We are also using very modern tools during development and testing, like cdk8s, a tool supported by Amazon that programmatically generates Kubernetes deployment specs that we can then launch on a small development cluster to enable developers to perform checks and verifications against a replica of the actual production environment for an extra guarantee of code correctness from a functional perspective. Using and exploring these modern tools is extremely interesting and motivating and allows you to grow as a developer.</p><p>In my next post, I will detail how we leverage a managed Kubernetes cluster at SIG to empower our developers with environments that allow for fast testing of features against a production setup. Stay tuned!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4643eea14bfa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softwareimprovementgroup/ci-cd-best-practices-how-to-set-up-your-pipeline-4643eea14bfa">CI/CD best practices: How to set up your pipeline</a> was originally published in <a href="https://medium.com/softwareimprovementgroup">Software Improvement Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Legacy Modernization: 6 architecture risks that could derail your program]]></title>
            <link>https://medium.com/softwareimprovementgroup/legacy-modernization-6-architecture-risks-that-could-derail-your-program-af4f12fb8793?source=rss----b58f22d3f9ab---4</link>
            <guid isPermaLink="false">https://medium.com/p/af4f12fb8793</guid>
            <category><![CDATA[architecture-quality]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[legacy-systems]]></category>
            <category><![CDATA[modernization]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Lijin Zheng]]></dc:creator>
            <pubDate>Tue, 09 Mar 2021 10:04:03 GMT</pubDate>
            <atom:updated>2021-03-09T10:04:03.056Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Part 2 of a two-part series sharing best practices for successful, cost effective transformation</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OuE4P79prsyyiHrF_gnbhg.jpeg" /></figure><p>In <a href="https://lijin-l-zheng.medium.com/legacy-modernization-the-art-of-choosing-the-right-scenario-ca9ef2b577e3"><strong>part 1</strong></a> of this series, we explained a three-phase approach to successful, cost-effective legacy system modernization:</p><p><strong>Phase 1</strong>: Prioritize your systems for modernization</p><p><strong>Phase 2</strong>: Determine modernization scenarios based on measurements of key architecture risks</p><p><strong>Phase 3</strong>: Monitor build progress continuously to stay the course</p><p>In this article, we’ll delve deeper into phase two and elaborate on why and how six critical architecture risks should be measured and used to develop the modernization project plan.</p><h4>Successful modernization is incremental and based on insight into architecture risks</h4><p>“Legacy” is actually much more than just outdated technology. Rather, it’s any pre-existing software solution that’s become too fragile for change, usually due to poor architecting or team knowledge loss. That means it can no longer evolve to support the ever-changing business goals for which it was originally created.</p><p>Based on our extensive experience in guiding large-scale legacy transformation programs, we’ve identified six key architecture quality risks that must be measured to determine the smartest scenario for system modernization.</p><p>Each risk represents the degree to which a system can be easily changed and/or evolved. Can changes to various parts be made in isolation, without fear of breaking another elsewhere? Can components be continually updated and adapted as the system grows?</p><p>The answers stem from how tightly coupled the components are within, and together, these six architecture risks provide a clear picture:</p><p><strong>1. Structure:</strong> <strong><em>The grouping of functional and technical areas in a code base</em></strong></p><p>Unlike modern systems with microservices or service-oriented architectures, legacy systems typically lack clear boundaries between functional and technical areas. The extreme example is a huge monolith with various problem areas in one big box. This makes it difficult to navigate issues, distribute maintenance effort, and extend functionality.</p><p><strong>2. Communication:</strong> <strong><em>The dependencies between functional or technical areas in a code base</em></strong></p><p>A common issue for legacy systems is “spaghetti code,” where dependencies are too intertwined to analyze and understand the functional logic mapped to code. The result is then that no one dares to touch any piece of code, as any change could lead to issues in production.</p><p><strong>3. Data Access:</strong> <strong><em>The way in which data is read or written to/from a database or other repository</em></strong></p><p>There’s usually only one big database for multiple functional areas of a legacy system. When many parts of a system depend on a single database, modifications to the data structure will very likely result in a cascading effect of modifications across the areas that rely on it, making the database schema for a legacy system too rigid for change.</p><p><strong>4. Technology Stack:</strong> <strong><em>The various technologies used in a code base</em></strong></p><p>Technology is usually the first thing selected for a system. Therefore, legacy systems always contain older or obsolete technologies, which are often more difficult for developers to work with. Obsolete technologies are typical impediments for development productivity, as there is little knowledge or tools available in the market as for modern technologies. Even worse, old technologies themselves become unsupported over time, which can expose big risks for business continuity.</p><p><strong>5. Evolution:</strong> <strong><em>The changes made to a code base over time</em></strong></p><p>In legacy systems, it’s difficult to make a change in one area without affecting another, making it difficult for multiple teams to work independently. This co-evolving behavior should be avoided, as not being able to isolate change is one of the biggest obstacles for development productivity.</p><p><strong>6. Knowledge:</strong> <strong><em>The degree to which knowledge of a code base is distributed among team members</em></strong></p><p>In working with our clients, we see a great deal of large legacy systems highly dependent on just one or two key developers. This means huge risks for business continuity; if these key developers leave or retire, sufficient knowledge of the systems will cease to exist.</p><h4>A new model to automate risk measurements</h4><p>The dependencies between these risks must be identified and quantified. Those measurements, however, are highly labor intensive and too tall of an order for most organizations.</p><p>For that reason, we’ve automated the measurements of all six of these aspects as part of a new architecture quality model. This model is based on the existing SIG methodology for standardized, repeatable measurements of source code using the ISO framework for software product quality.</p><p>The model’s results provide for modernization scenarios — such as rebuilding, refactoring, or re-platforming. They also consider code replacements and what to (potentially) keep. Even more importantly, the results can be used to produce detailed recommendations per scenario about which system modules to address first. Each scenario must be supported by cost estimates and a comparison between maintenance efforts in the first year and those thereafter.</p><h4>Final thoughts</h4><p>The demands of the new digital transformation economy are calling on organizations to stop relying on inflexible software and modernize their core technologies. But the successful road to transformation is incremental and paved with facts about the system’s architecture quality.</p><p>Only when these six most critical architecture risks are made clear upfront and in detail, linked both to code and component levels, can the modernization program be executed with granular focus, highest productivity, and lowest costs. Our team is ready and available to create your fact-based, risk-managed roadmap.</p><p><em>Read </em><a href="https://lijin-l-zheng.medium.com/legacy-modernization-the-art-of-choosing-the-right-scenario-ca9ef2b577e3"><strong><em>part 1</em></strong></a><em> in this series: Legacy Modernization: The art of choosing the right scenario</em></p><p><strong>About the Authors</strong></p><p><em>Lijin Zheng is a Consultant at SIG specializing in legacy modernization.</em></p><p><em>Michel van Dorp is Vice President of Strategic Partnerships at SIG, working with global consulting and technology firms to execute on efficient, cost-effective legacy modernization programs.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af4f12fb8793" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softwareimprovementgroup/legacy-modernization-6-architecture-risks-that-could-derail-your-program-af4f12fb8793">Legacy Modernization: 6 architecture risks that could derail your program</a> was originally published in <a href="https://medium.com/softwareimprovementgroup">Software Improvement Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Legacy Modernization: The art of choosing the right scenario]]></title>
            <link>https://medium.com/softwareimprovementgroup/legacy-modernization-the-art-of-choosing-the-right-scenario-ca9ef2b577e3?source=rss----b58f22d3f9ab---4</link>
            <guid isPermaLink="false">https://medium.com/p/ca9ef2b577e3</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[modernization]]></category>
            <category><![CDATA[architecture-quality]]></category>
            <dc:creator><![CDATA[Lijin Zheng]]></dc:creator>
            <pubDate>Tue, 09 Mar 2021 10:03:19 GMT</pubDate>
            <atom:updated>2021-03-09T10:03:19.387Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Part 1 of a two-part series sharing best practices for successful, cost effective transformation</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xknRYoJPuLuUIn3GV2xgRg.jpeg" /></figure><p>Organizations have long been under pressure to evolve their software landscapes in a way that aligns with ever-changing business demands.</p><p>IT teams everywhere want to make the leap to modernization, but the initiative presents enormous challenges and risks. In fact, 74% of organizations fail to complete legacy modernization projects, according to a recent report by <a href="https://www.oneadvanced.com/trends-report/2020-21/"><strong>Advanced</strong></a>.</p><p>To add yet another complexity to the mix, there are so many different roads leading to modernization. The question then becomes how to choose the <em>right</em> one, around all the costs and pitfalls?</p><p>The short answer: With clear insight into your architecture quality and risks before even making a start.</p><h3>Successful modernization requires upfront insight into architecture quality and risk</h3><p>Take sailing, for example. A crew never sets out without advanced knowledge about the trouble spots along the route. They also need to keep a close eye on changing conditions throughout the journey to stay the course.</p><p>The same holds true for modernizing legacy systems. The technology leader first needs facts about the quality and risk of the software architecture in order to map a successful route to the target state — along with continuous data throughout the life of the program to ensure progress.</p><h3>A fact-first, 3-phase approach</h3><p>We’ve been guiding our clients in large-scale modernization programs for two decades, taking a “fact-first” approach to assess architectural composition, current system build quality, data stores, and active knowledge of development teams. Those findings are then translated into risk-based roadmaps, mapping a route to transformation around the danger zones.</p><p>We believe the successful transformation program comprises three phases:</p><h4>Phase 1: Prioritize your systems for modernization</h4><p>During the planning and budgeting phase, teams need a comprehensive overview of the entire portfolio to identify which systems should be modernized first. Combining these with the business priorities will help to define the best order and accommodate for the appropriate budgets.</p><p>To help provide our clients with this insight, we’ve developed a lightweight quick scan that evaluates select software quality aspects against the SIG benchmark. Based on those results, a prioritized list of legacy modernization candidates is created from a technical perspective.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jV46AHQgZgv43Spd.png" /></figure><h4>Phase 2: Determine modernization scenarios based on measurements of key architecture risks</h4><p>Once the system(s) has been slated for modernization, the overall quality of its architecture needs to be brought to light. To do so, we’ve identified six key architecture risks which should be measured before you can determine the smartest modernization scenario:</p><ul><li>Structure</li><li>Communication</li><li>Data Access</li><li>Technology Stack</li><li>Evolution</li><li>Knowledge</li></ul><p>Each architecture risk represents the degree to which the system can be easily changed and/or evolved, which stems from how tightly coupled the components are within.</p><p>The measurements of each can be automated using the SIG architecture quality model, which we’ll explain further in <a href="https://www.softwareimprovementgroup.com/resources/legacy-modernization-6-architecture-risks-that-could-derail-your-program/"><strong>part 2</strong></a> of this series.</p><p>The model’s results as well as a functional decomposition allow for modernization scenarios, such as rebuilding the whole system, or refactoring specific parts of it, as well as estimation of the cost, effort, and time for each.</p><p>Prioritization of refactoring activities must be ROI-focused. Resources should be allocated (based on the identified risks) to the components that will deliver the highest return on the effort, allowing development teams to make the biggest impact from the available budgets.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*YooSw5wnAPjA3Li4.png" /></figure><p>During this second phase, not only is the right modernization approach identified, but a detailed project plan is also developed to manage it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ftPut7t-_O2Xg7ux.png" /></figure><p>Once the most favorable scenario has been identified and the plan created, the actual execution can begin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*X-t4P5xu_Tmo3z6_.png" /></figure><p>The outcome of the automated architecture quality measurements can now be used to focus on the connections between the critical components to be replaced first.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/0*u75c0NzS7VTG1VnA.png" /></figure><h4>Phase 3: Monitor build progress continuously to stay the course</h4><p>By now, you’re equipped with a fact-based, risk-managed roadmap to modernization, having had facts about your system architecture translated into the optimal scenario. But just as the sailing crew has to stay on top of ever-changing conditions at sea, the IT team needs continuous insight in this third phase of modernization to assure progress to the target state.</p><p>Both the legacy and new code and their dependencies should be monitored continuously in a software assurance platform, like <a href="https://www.softwareimprovementgroup.com/solutions/sigrid-software-assurance-platform/"><strong>Sigrid</strong></a> from SIG, to maintain a clear overview and accurate picture of the progress made as well as the work still left to be done. As another important benefit, Sigrid also indicates the refactoring candidates in the legacy system with the largest impact on the software quality score, helping development teams prioritize the work in their sprints.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/0*G_kEiE9VQ5ChrskK.png" /></figure><h3>Final thoughts</h3><p>Organizations spend considerable time and financial resources maintaining legacy systems, but fundamental changes are inevitably required to improve process efficiency, create better ways of serving customers, and capture opportunities for future growth.</p><p>The three-phase approach explained in this article has proven its value for a wide variety of technology use cases, from transformation of large Cobol monoliths to implementing low-code applications as replacements for older technologies, spanning industries in both the public and private sectors.</p><p>The organizations who choose this fact-based, risk-managed path will find themselves well on their way to a foundation for future innovation. Our team is ready to support your journey.</p><p><em>Read </em><a href="https://lijin-l-zheng.medium.com/legacy-modernization-6-architecture-risks-that-could-derail-your-program-af4f12fb8793"><strong><em>part 2</em></strong></a><em> in this series: Legacy Modernization: 6 architecture risks that could derail your program</em></p><p><strong>About the Authors</strong></p><p><em>Lijin Zheng is a Consultant at SIG specializing in legacy modernization.</em></p><p><em>Michel van Dorp is Vice President of Strategic Partnerships at SIG, working with global consulting and technology firms to execute on efficient, cost-effective legacy modernization programs.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ca9ef2b577e3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softwareimprovementgroup/legacy-modernization-the-art-of-choosing-the-right-scenario-ca9ef2b577e3">Legacy Modernization: The art of choosing the right scenario</a> was originally published in <a href="https://medium.com/softwareimprovementgroup">Software Improvement Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>