<?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[Stories by Ivan Sanchez on Medium]]></title>
        <description><![CDATA[Stories by Ivan Sanchez on Medium]]></description>
        <link>https://medium.com/@s4nchez?source=rss-67dd819eb35f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*At_D3opGN4t85iZkJWTt6w.jpeg</url>
            <title>Stories by Ivan Sanchez on Medium</title>
            <link>https://medium.com/@s4nchez?source=rss-67dd819eb35f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 21:08:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@s4nchez/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Creating testing-friendly Kotlin services with http4k]]></title>
            <link>https://medium.com/google-developer-experts/creating-testing-friendly-kotlin-services-with-http4k-ac2233e6d0ca?source=rss-67dd819eb35f------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac2233e6d0ca</guid>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[google-developer-expert]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[google]]></category>
            <dc:creator><![CDATA[Ivan Sanchez]]></dc:creator>
            <pubDate>Mon, 09 Jan 2023 22:42:56 GMT</pubDate>
            <atom:updated>2023-01-09T22:42:56.861Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VSAWPFCAg-II2CkCVoSPYQ.jpeg" /><figcaption>Re-configurable electric contraption (Photo by John Barkiple via Unplash)</figcaption></figure><p><em>Whether you’re practicing Test-Driven-Development or just creating any kind of test automation around your service APIs, you can benefit from code that makes life easier for testing.</em></p><p>Let’s check how http4k uses the simplicity of Kotlin to make services easy to test without compromising on the developer experience.</p><p>You can get a new http4k project setup from scratch is using the <a href="https://toolbox.http4k.org/project">http4k Project Wizard</a> (or skip that step completely and dowload a simple Hello World project <a href="https://toolbox.http4k.org/stack/dD1BQU1BWlFETEFTMEQ2QVBwQkxBRkZ3JmM9SGVsbG9Xb3JsZCZwPWNvbS5leGFtcGxl">here</a>)</p><p>Alternatively, all just need to add the http4k-core dependency to your project:</p><pre>implementation(&quot;org.http4k:http4k-core:4.35.3.0&quot;)</pre><p>Now, back to creating a service. Here’s all you need to get started:</p><pre>val service = { request: Request -&gt; Response(OK).body(&quot;Hello World&quot;) }</pre><p>Yes, that’s something you can already use for testing. It looks like a simple function, because it is just that: a <strong>server as a function</strong>.</p><p>What does invoking this server look like? Well — as our server is a standard Kotlin function, it just returns the constructed response:</p><pre>val response = service(Request(GET, &quot;/&quot;))<br><br>assertThat(response.status, equalsTo(Status.OK)<br>assertThat(response.bodyString(), equalsTo(&quot;Hello World&quot;))</pre><p>This is the foundation of http4k:</p><blockquote><em>A server is a function, and you can just use it as such</em>.</blockquote><p>To achieve that, http4k takes advantage of Kotlin’s <a href="https://kotlinlang.org/docs/type-aliases.html">type aliases</a> (HttpHandler is an alias for (Request) -&gt; Response). Also, both request/response are <a href="https://kotlinlang.org/docs/data-classes.html">data classes</a>, which are immutable and easy to create and modify.</p><p>By now, you’re problably asking yourself: that doesn’t look like something one could use in production, where we want real HTTP clients accessing the service, which will be running somewhere and accessible only via network on a given port. Where’s all that?</p><p>To answer that, let’s take our service and make it work over the network:</p><pre>service.asServer(SunHttp(8000)).start() //starts a server on port 8000<br>val client = JavaHttpClient()<br><br>val response = client(Request(GET, &quot;http://localhost:9000&quot;))<br><br>assertThat(response.status, equalsTo(Status.OK)<br>assertThat(response.bodyString(), equalsTo(&quot;Hello World&quot;))</pre><p>In this case, our server is running as a real HTTP server using http4k’s .asServer <a href="https://kotlinlang.org/docs/extensions.html">extension function</a> and SunHttp as the choice of real server implementation. It uses code available in the JDK so there’s no extra dependency, but http4k also offers other options such as Jetty, Netty, Undertow and even Ktor.</p><p>We also introduce an HTTP client, JavaHttpClient, which is also using code built into the JDK. And once again, using a single line of code we can swap that several others including OkHttp and Apache.</p><p>This is a common theme behind a lot of http4k’s 50 or so integration modules — it provides a consistent shim over these libraries, allowing the API user to mix and match which ones they are familiar with, whilst integrating seamlessly with a small set of foundational concepts.</p><p>As for testing, the biggest breakthrough in http4k is that both clients and servers use the same function definition (the type alias mentioned above):</p><pre>typealias HttpHandler = (Request) -&gt; Response</pre><p>That makes clients and servers interchangeable for testing purposes. For example, you can replace the client with the server definition in test above without touching your assertion:</p><pre>val service = { request: Request -&gt; Response(OK).body(&quot;Hello World&quot;) }<br>val client = service<br><br>val response = client(Request(GET, &quot;http://localhost:9000&quot;)) //uri is irrelevant<br><br>assertThat(response.status, equalsTo(Status.OK)<br>assertThat(response.bodyString(), equalsTo(&quot;Hello World&quot;))</pre><p>This brings some major benefits:</p><ol><li>Creating testing data is simple as request and responses are just data classes.</li><li>Tests run an order of magnitude faster as they skip the network completely, and are unaffected by port clashes.</li><li>There is no separate test infrastructure required for testing. Service setup in tests is identical to production code.</li><li>Multiple services can be wired to each other by replacing clients with server implementations. That means tests can cover a whole system as function.</li><li>You can reuse test and run the same test in-memory, against servers running on the local machine, or even against a full-blown deployed environment.</li></ol><p>The examples above don’t go into details such as endpoint <a href="https://www.http4k.org/guide/howto/simple_routing/">routing</a>, middleware (<a href="https://www.http4k.org/guide/howto/simple_routing/">filters</a>), or handling <a href="https://www.http4k.org/guide/howto/simple_routing/">complex, type-safe request/response bodies</a>. All of those features are available and built on top of the same function definition and without any special reflection or annotation mechanism.</p><p>That means the same testability you see above can be achieved no matter how complex you service is.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac2233e6d0ca" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-developer-experts/creating-testing-friendly-kotlin-services-with-http4k-ac2233e6d0ca">Creating testing-friendly Kotlin services with http4k</a> was originally published in <a href="https://medium.com/google-developer-experts">Google Developer Experts</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CITCON 2022 Musings]]></title>
            <link>https://s4nchez.medium.com/citcon-2022-musings-6e676166beec?source=rss-67dd819eb35f------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e676166beec</guid>
            <category><![CDATA[conference]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[citcon]]></category>
            <dc:creator><![CDATA[Ivan Sanchez]]></dc:creator>
            <pubDate>Sat, 15 Oct 2022 06:59:35 GMT</pubDate>
            <atom:updated>2022-10-15T06:59:35.650Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XncB7YW4R_fclZ8ZWQD_Jw.jpeg" /></figure><p>One of my favourite things about <a href="https://en.wikipedia.org/wiki/Open_Space_Technology">Open Space</a> tech conferences is that it shows what a group of people cares about at that time. <a href="https://www.citconf.com/">CitConf</a> covers the intersection of technical and non-technical aspects of what it takes to ship good software and attracts people with a variety of roles, contexts and backgrounds. That’s an excellent recipe for insightful conversations and why many attendees return year after year.</p><p>This year, the proposed topics highlight how some problems in the software industry take years or decades to tackle. For example:</p><ul><li>“How to murder manual testing”</li><li>“What does ‘shift left’ mean to you in software development and testing?”</li><li>“Monitoring Driven Development (MDD) / Why are you afraid to test in production?”</li></ul><p>It also shows that organisational challenges are a never-ending source of topics:</p><ul><li>“Dynamic re-teaming in practice”</li><li>“Alignment or autonomy?”</li><li>“Convince me I should go back to the office”</li><li>“Tech hiring 2.0”</li></ul><p>Finally, I’m glad to see some deeper not-necessarily-technical topics such as:</p><ul><li>“Self-care (how to ground/breath awareness meditation)”</li><li>“The joy of software development”</li></ul><p>Based on the sample above and my experience on previous editions, I’m confident this will be another great CitConf and we’ll finish with plenty of insights and new tricks to try.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e676166beec" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[App Anatomy: a sociotechnical pattern for continuous delivery infrastructure]]></title>
            <link>https://s4nchez.medium.com/app-anatomy-f4215fffca16?source=rss-67dd819eb35f------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4215fffca16</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <dc:creator><![CDATA[Ivan Sanchez]]></dc:creator>
            <pubDate>Sat, 25 Sep 2021 13:07:44 GMT</pubDate>
            <atom:updated>2021-12-09T09:05:56.724Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Human anatomy illustration" src="https://cdn-images-1.medium.com/max/1024/1*WN55sPs7_Cv4v6cNNhQJ6Q.jpeg" /><figcaption>Image by Victor Rodriguez via Unsplash</figcaption></figure><h3>Problem</h3><p>Organisations building multiple applications (services, websites, apps, etc) and adopting Continuous Delivery are required to maintain the infrastructure required to build, configure, and deploy each application.</p><p>This <em>Continuous Delivery Infrastructure</em> (CDI) covers aspects such as:</p><ul><li>Continuous Integration (pipeline definitions)</li><li>Deployment Procedures (encoded in pipelines or separate tooling)</li><li>Application/environment configuration for deployment</li><li>Observability &amp; Monitoring (external applications and dashboards)</li></ul><p>As the number of applications and teams grow, those should be standardised across the organisation so teams don’t have to reinvent the wheel and good practices can spread.</p><p>The organisation at that stage makes a choice (not always deliberate) of who is responsible for maintaining both the standards and the actual infrastructure.</p><p>In some cases, a central team is the one creating and maintaining at least part of the CDI for teams. That usually means slower lead times for changes in that area, as creating and updating any aspect of the infrastructure will require coordination with a different team. In return, this team has the opportunity to implement standards and facilitate good practices and reuse across delivery teams.</p><p>An alternative approach is letting teams have access to tools and environments so they can set up things the way they need when they need it. This means greater autonomy for teams to evolve their solution and experiment with new approaches. Unfortunately, it means that it becomes less likely teams will approach things similarly, there’s the extra overall effort required by each team, and it’s likely teams will have to learn various lessons the hard way before they get to a good place.</p><p>In addition, making sense of this landscape and answering simple questions such as who owns a particular service in production, or has the application been scanned for vulnerabilities also becomes harder and harder depending on the approach chosen.</p><h3>Solution</h3><p>Instead of having teams creating their own CDI solutions, or a centralised team responsible for each application’s CDI individually, the App Anatomy pattern is based on a central framework maintained by a platform team plus controlled autonomy for delivery teams.</p><p>This is achieved with four elements:</p><h4>1. Conventions for various application elements</h4><p>Conventions are defined to eliminate unnecessary deviation and the need for extra tooling.</p><p>For instance, the application name may be the directory name of where it lives in the source control system. The name of the pipeline in the continuous integration system will also use the same name. Same thing for names of dashboards that are automatically managed.</p><p>These conventions are enforced by software and encode what the organisation considers good practice.</p><p>Other examples are:</p><ul><li>Each application needs a README and CONTACT file with certain content in them.</li><li>All applications are built by calling a build script (which can delegate to language-specific building tools).</li><li>A service gets deployed to an environment if all tests pass and no manual gatekeeping mechanism is defined.</li></ul><h4>2. Definition of an application descriptor (a.k.a. app anatomy)</h4><p>Not all things can be derived from convention when different teams have different needs, and that’s where the app anatomy information (coming from statics file or output from hook script) comes in.</p><p>It allows defining extra parameters used to define the CDI for a particular application.</p><p>The app anatomy contains important application details such as:</p><ul><li>Required dependencies (libraries or other services)</li><li>Where the application should be deployed and whether manual approval is required</li><li>Configuration variants (per environment in case of services, or per different builds of mobile apps)</li><li>Extra resources needed (domain names, databases, static assets)</li><li>Where test results and other build reports can be found</li><li>What’s the team that currently maintains the application</li><li>Exceptions to the conventions (e.g. different service name)</li></ul><p>Those bits of information (plus conventions) are used to drive the creation and maintenance of all infrastructure to build, deploy, and operate the application.</p><h4>3. Central automation tooling (a.k.a. auto pipeline)</h4><p>Once conventions and other metadata are available in source control for each application, central automation tooling will monitor changes and apply them to the CDI.</p><p>This tool (or set of tools) is responsible for the automation of tasks that teams (delivery or central) would manually normally perform such as defining build pipeline or configuring deployment parameters.</p><p>Another common responsibility of this central tooling is to act as the repository of information about what applications are being developed, by whom, and how.</p><h4>4. Secondary tools for information radiation and wider organisation use</h4><p>With central automation in place, it becomes possible to create documentation that by definition won’t get out-of-date over time. It also allows building more specialised reporting around topics the organisation may care about such as testing approach or security metrics.</p><p>Depending on the design of the automation tooling, it can also be extended by other teams from the organisation to perform relevant tasks such as alerting when a particular service gets deployed to production or automatically running business-specific post-deployment tasks.</p><h3>Consequences</h3><p>The main consequence of this pattern is that it allows organisations to find their sweet spot between giving teams autonomy and having (self-enforcing) standards in place.</p><p>This approach reduces development efforts for teams, as they don’t have to jump into infrastructure code every time they need to create or update the CDI for a particular application. Instead, they can leverage previous knowledge about the conventions and tooling to focus on business challenges rather than technical details.</p><p>For the wider organisation, a benefit of this approach is automated governance of their applications. Because CDI is managed by central tooling, it becomes easier to inspect everything being built and deployed and collect all sorts of useful information such as ownership details and inter-dependencies.</p><p>Another organisational benefit is that app anatomy reduces friction for engineers to move between teams.</p><p>Unsurprisingly, this pattern doesn’t come for free, and there are some trade-offs that need to be taken into account.</p><p>The main one is that App Anatomy requires investment. Organisations have very specific requirements when it comes to building and deploying applications, and finding suitable off-the-shelf solutions for App Anatomy is extremely difficult.</p><p>There are solutions that follow a similar approach for part of the application lifecycle (Heroku and Travis being notable examples) and those are good to get started but are also limited for those wanting to unlock the full potential of this approach.</p><p>By requiring internal development it also means App Anatomy is a solution that doesn’t get built overnight. It requires a group of people dedicated to understanding what good looks like for the organisation. This team also needs to be able to work with teams to encode and document the right conventions, as well as support teams during the transition to this approach.</p><p>Finally, there are also ongoing costs to maintain such a solution. Most organisations will benefit from iterating on their solution, and keep educating new teams and individuals on the approach. Also, App Anatomy tooling itself requires infrastructure to run.</p><p>Still, for organisations trying to scale their Continuous Delivery capabilities, the benefits of App Anatomy are likely to outweigh these costs over time, as it reduces the variance of solutions to the same problem and unlocks building solutions that all teams (and the organisation as a whole) can benefit at once.</p><h3>Background</h3><p>I’ve first come across this pattern at a large scientific publisher in London.</p><p>Although the origins of the “app anatomy” name and pattern are unclear, the implementation led by <a href="https://twitter.com/sf105">Steve Freeman</a>, <a href="https://twitter.com/ivanrmoore">Ivan Moore</a>, and a small “tools engineering” team made dozens of teams extremely effective at shipping high-quality software to production quickly and with low friction.</p><p>There’s a <a href="https://skillsmatter.com/skillscasts/6925-a-meta-pipeline-for-generating-continuous-delivery-pipelines-for-microservices">talk</a> by <a href="https://twitter.com/hilverd">Hilverd Reker</a> and <a href="https://twitter.com/sf105">Steve Freeman</a> that goes into more details of that particular implementation and provides a good taste of this pattern in practice.</p><p>Thank you <a href="https://twitter.com/ivanrmoore">Ivan Moore</a>, <a href="https://twitter.com/natpryce">Nat Pryce</a>, <a href="https://twitter.com/savagematt">Matt Savage</a>, <a href="https://twitter.com/tarkaTheRotter">David Denton</a>, and <a href="https://twitter.com/jshiell">James Shiell</a> for the various conversations around this topic and input for this article.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4215fffca16" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why are Java server-side developers not adopting Kotlin?]]></title>
            <link>https://medium.com/google-developer-experts/why-are-java-server-side-developers-not-adopting-kotlin-8eb53e06ee99?source=rss-67dd819eb35f------2</link>
            <guid isPermaLink="false">https://medium.com/p/8eb53e06ee99</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[organisational-culture]]></category>
            <dc:creator><![CDATA[Ivan Sanchez]]></dc:creator>
            <pubDate>Wed, 03 Mar 2021 18:15:51 GMT</pubDate>
            <atom:updated>2021-03-05T13:41:18.456Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gm96YTYteHAnbUdIRpjtlw.jpeg" /><figcaption>Image by Victor Rodriguez via Unsplash</figcaption></figure><p><em>TL;DR — What I see in the wild is that Kotlin adoption on the server-side is slow due to a mix of complacency, career self-preservation, and lack of Kotlin visibility. In some specific cases, though, avoiding the adoption is entirely justified.</em></p><p>It’s now almost five years since I wrote my first lines of Kotlin, after using Java for over fifteen years.</p><p>Our team didn’t follow the typical Java playbook: we used <a href="https://github.com/bodar/utterlyidle">Utterlyidle</a> instead of Spring and embraced a Functional Programming approach with <a href="https://totallylazy.com/">Totallylazy</a>. We were big fans of IntelliJ and tried to take full advantage of the tooling it provided for Java.</p><p>At that time, we were already looking beyond Java. There was some interest in Scala by some teams, and we had a few services already written in it. But the complexity, pain to work alongside a Java codebase, and slow build times made that language unappealing to most of us.</p><p>When Google <a href="https://blog.jetbrains.com/kotlin/2017/05/kotlin-on-android-now-official/">announced</a> Kotlin was becoming an official language for Android development in 2017, another team close to us evaluated the language for their server-side development. Eventually, most of us were giving it a try.</p><p>I was blown away by the impact Kotlin had on our codebase. It felt more productive, safer, and the tooling, although not anywhere as mature as Java’s, was good enough to make the adoption worth it.</p><p>It was also fun to move away from a language that felt old and verbose, and discover what coding styles fit well with Kotlin’s features. The excellent interoperability with Java meant that we could rely on the existing ecosystem and transition systems incrementally, without significant disruption to getting things done.</p><p>Soon, my interest in Kotlin resulted in co-creating <a href="https://http4k.org/">http4k</a>, a Functional toolkit for Kotlin HTTP applications, and running the <a href="http://web.archive.org/web/20191105124733/https://skillsmatter.com/courses/602-real-world-kotlin-development-workshop">Real World Kotlin Development workshop</a> to help other teams attempting to make the same transition.</p><p>Eventually, I’ve moved to other positions but was lucky enough to see Kotlin used on the server-side in various other projects. And I also experienced firsthand a number of reasons for teams to be strongly reluctant to adopt Kotlin.</p><p>It’s curious to see that the resistance doesn’t always arise from the merits of the actual language. So why hasn’t the Java server-side community adopted Kotlin more heavily?</p><p>Here are some reasons my colleagues and I have encountered:</p><h4>“We don’t have time to learn a new language.”</h4><p>That’s a variation of “too busy chopping wood to sharpen the axe” we commonly see in software projects. It’s usually a sign of deeper issues like mounting technical debt and general productivity issues.</p><p>Healthy software projects always involve a fair amount of learning. And a competent Java developer can get the basics of Kotlin in hours and will be reasonably productive in days.</p><p>A worthwhile investment once the productivity gains kick in when they write simpler code an deal with fewer issues because of the new language.</p><h4>“Java is getting better with each release.”</h4><p>That is true: Java is getting better. And releases are coming out faster. On the other hand, it’s still miles behind Kotlin in simple things like dealing with nullability.</p><p>Maybe the Java community is used to the language’s evolution pace. Still, Kotlin provides a way to take advantage of many of those features (and more) in their projects today rather than tomorrow.</p><h4>“We are happy as Java developers.”</h4><p>This kind of resistance is the trickiest one. There’s not much one can do if a programmer ties their professional identity to a single programming language.</p><p>On the one hand, I understand if Java developers don’t want to gamble their careers by jumping into a new language’s unknown waters. Or they want to be a long-term specialist. And that’s fair enough.</p><p>On the other hand, I’m yet to see a Java developer “fall behind” because they were using Kotlin. On the contrary, it shows they are continuously looking for the best tool for their jobs, which is a positive trait, at least on the people I help hiring.</p><h4>“Kotlin is a hyped language with an unknown future.”</h4><p>That was a common objection we saw around 2017. In that year, Google embraced Kotlin as a first-class language for Android development, reassuring us that big players are interested in the language’s longevity.</p><p>Today, this is probably less common, given that popular frameworks like <a href="https://spring.io/guides/tutorials/spring-boot-kotlin/">Spring</a> and <a href="https://guides.micronaut.io/creating-your-first-micronaut-app-kotlin/guide/index.html">Micronaut</a> seem to have embraced the new language.</p><p>Hopefully, that’ll give enough visibility to the language for more server-side people to give it a try.</p><h4>“I’m using Eclipse and don’t want to switch to IntelliJ.”</h4><p>It’s fair to say that the Kotlin experience in Eclipse probably doesn’t match JetBrains IDEA.</p><p>That’s understandable since JetBrains business model includes selling their developer tools. And that’s unlikely to change anytime soon.</p><p>The only hope for those is Kotlin reaching a critical mass that justifies the further investment in Eclipse support. Until then, the best developer experience for Kotlin developers will remain on JetBrains products.</p><p>My very biased view is that IntelliJ is already a better IDE for Java anyway, so it may be worth giving the switch a try too.</p><h4>“Kotlin developers are too expensive and hard to come by.”</h4><p>This one is hard to assess: looking at <a href="https://www.itjobswatch.co.uk/default.aspx?q=kotlin%2C+java">salary websites</a>, one could conclude that Kotlin salaries are slightly higher overall.</p><p>That’s a hard comparison to make if we want to consider server-side developers only. In general, that’s the Java area that pays the highest, and there’s not enough data on the Kotlin side to compare.</p><p>Anecdotally, we see in practice that senior Java developers are often the first ones adopting Kotlin, which may give the impression that Kotlin developers are expensive.</p><p>On the recruiting side, we haven’t seen issues attracting Kotlin developers. We are clear that the job requires using the new language and accept that developers will learn it on the job.</p><p>That seems to put Java developers at ease and attract those keen to learn new things, which is also a good indicator of potential fit.</p><h4>“Kotlin is too complicated.”</h4><p>One of the reasons Kotlin makes for a compelling alternative to languages like Scala is that it struck a decent balance between developer ease of use and advanced features to make operability with Java and adoption by popular frameworks possible.</p><p>In practice, this kind of objection tends to be related to the individual team’s skills, style, and conventions.</p><p>Beginners tend to start writing Kotlin just like they’d write Java. As they get more comfortable with the language, they’ll likely push some features (e.g. extensions and inline functions) too far, making the codebase impenetrable to newcomers.</p><p>Until a team is fully competent in the new language, we strongly advocate using Boring Kotlin(TM) for as long as possible. Eventually, most of the team will be comfortable enough to find the balance between picking cool language features and making the code accessible to the whole team.</p><h4>“It’s confusing having two languages in one codebase.”</h4><p>That’s a common fear from people who haven’t tried Kotlin in a real project.</p><p>In practice, as long as the team is on board and mindful that the new Kotlin code needs to co-exist with Java at first, using the two languages in a single project doesn’t bring significant pain.</p><p>A rule that can help is: “if a change touching the two languages, first start by converting the old code to Kotlin”.</p><p>That way, the team can avoid a big-bang rewrite and incrementally migrate the areas where they need to add new value.</p><p>If some code remains in Java, that’s also ok. Most likely, it’s because the code works, and there’s no pressing need to refactor it.</p><h4>“We are more comfortable in Java.”</h4><p>In practice, it may be that a given context doesn’t call for the new language. Everything is working fine; the team is getting things done at an acceptable pace and has a good grip on the issue that Kotlin would help address.</p><p>In our experience, however, that’s the exception and not the rule. More often than not, this kind of resistance originates from a general lack of time or interest in learning rather than a lack of areas to improve.</p><p>It’s also hard to experience the benefits of Kotlin until trying on a real project, and introducing a new language, even as an experiment, can cause a lot of anxiety.</p><p>In those cases, we recommend <a href="https://deming.org/institute-training-on-the-job/">“Learning on the Job”</a> (in the form of coding dojos, brown-bag sessions, etc.) to create a safe environment where this kind of experimentation can happen.</p><p>This approach allows the team to assess both their use of Java and if it’s worth investing in Kotlin.</p><h4>“I don’t see what advantages Kotlin would bring.”</h4><p>Sometimes Java developers are unaware of the language limitations or are too used to them. Other times, they’ll dismiss any alternative that makes them question their current language of choice.</p><p>Without getting into details, we could say that Kotlin’s conciseness and safety are its <a href="https://kotlinlang.org/#why-kotlin">main advantages</a>. However, some will claim they don’t see an issue with Java’s verbosity and write safe code already.</p><p>It’s easy to dismiss Kotlin before trying it, and when faced with the option, a few people will continue to look for reasons not to try.</p><h4>Final thoughts</h4><p>Adopting a new programming language, especially on ongoing projects, poses a challenge for most teams. It’s also important to accept that the resistance to change is highly context-specific and will come from project needs and personal reasons, as well as the language itself.</p><p>Having said that, I’d still encourage more developers working on Java server-side to give Kotlin a try if they get a chance. If nothing else, it may highlight other areas of improvement beyond the code.</p><p>Thank you <a href="https://twitter.com/ramtop">Uberto Barbini</a>, <a href="https://twitter.com/dmitrykandalov">Dmitry Kandalov</a>, <a href="http://dentondav.id/">David Denton</a>, and <a href="https://github.com/ToastShaman">Kevin Denver</a> for the extra ideas and review of this post.</p><p>Let me know your thoughts about the topic on <a href="https://twitter.com/s4nchez">Twitter</a>. You can also find this and my previous articles on <a href="https://isanchez.net/posts">my website</a>.</p><p><a href="https://dogged-knitter-3175.ck.page/54c019f057">Want to accelerate your Kotlin adoption?</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8eb53e06ee99" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-developer-experts/why-are-java-server-side-developers-not-adopting-kotlin-8eb53e06ee99">Why are Java server-side developers not adopting Kotlin?</a> was originally published in <a href="https://medium.com/google-developer-experts">Google Developer Experts</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Perks for adult developers]]></title>
            <link>https://s4nchez.medium.com/perks-for-adult-developers-9715ee260c1a?source=rss-67dd819eb35f------2</link>
            <guid isPermaLink="false">https://medium.com/p/9715ee260c1a</guid>
            <category><![CDATA[organizational-culture]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[culture]]></category>
            <dc:creator><![CDATA[Ivan Sanchez]]></dc:creator>
            <pubDate>Tue, 23 Feb 2021 09:26:44 GMT</pubDate>
            <atom:updated>2021-02-23T09:26:44.038Z</atom:updated>
            <content:encoded><![CDATA[<p>In addition to a good salary, there are many ways companies try to attract and retain good people.</p><p>Those benefits tend to say a lot about the organisation culture, which explains why companies bragging about their ping-pong tables have become a running joke in the industry.</p><p>Here are some tips in case your company intends to treat developers like actual adults, as in <a href="https://en.wikipedia.org/wiki/Chris_Argyris#Adult_personality">Chris Argyris’ Theory of Adult Personality</a>:</p><h3>Give the best tools for the job, no questions asked</h3><p>Just provide the best hardware (laptop, chairs, cameras, etc.) and software the team considers appropriate without making a big deal out of it.</p><p>If the team can’t agree on what those are, work with them first to define a shortlist, publish it internally, and invite them to refer to that.</p><p>It’s surprising how many companies still forget that tools are cheap compared to people’s salary and (hopefully) the value they can create if only they’re allowed to be effective.</p><h3>Remove general friction</h3><p>Many levels of approval to get hardware or access to internal systems? Detailed justification to take a day off or a more extended holiday? No access to install other software in their work laptops?</p><p>Be mindful of adding any friction like that. Unless people are onboard with the trade-off a restriction represents, it’ll just be another source of complaint and comparison when looking for another job.</p><p>In many cases, a <a href="https://en.wikipedia.org/wiki/Trust,_but_verify">Trust But Verify</a> approach would be more suitable for reducing issues while still keeping people productive.</p><h3>Allow and encourage to continuously improve things</h3><p>Like any other person in the organisation, developers are well placed to identify their work issues. Not giving them space and autonomy to fix them is missing valuable opportunities to make the whole organisation better.</p><p>That shouldn’t be limited to improvements to the code. Better tools, processes, and working practices should also be up for grabs for those who see areas to improve.</p><h3>Allow and encourage to work with the broader organisation</h3><p>It’s still common for organisations to treat software development as an isolated function that turns requirements from team A into software that team B will run and C will maintain.</p><p>Adult developers want to understand the “why”, help defining the “what”, and direct the “how”. That means collaborating with all the people impacted by their work.</p><p>At a minimum, the information flow needs to be available so they can make well-informed decisions. And in return, developers should be able to share constraints and implications of those directions in a way others can understand.</p><p>High-performance organisations require cross-discipline/team collaboration, and great developers are well aware that their best output will come from working with other people.</p><h3>Support career development</h3><p>Most adult developers don’t enjoy the Personal Development Plans (PDPs) their employers force them to define and follow. That becomes even worse when those become tied to career progression and salary reviews.</p><p>On the other hand, developers appreciate having good coaches or mentors they can refer to when they need support.</p><p>For more senior developers, this support often means providing a light-touch approach of giving them space to grow on their own but still giving feedback when asked or needed.</p><p>An appropriate allowance for learning (books, courses, going to conferences, etc.) is also welcome by developers at any level.</p><h3>Summary</h3><p>Hopefully, if those ideas sound like common sense, it probably means your company is already on the right track.</p><p>On the other hand, if those sound too hard or even impossible in your context, your organisation may be past the stage where treating developers like an adult is possible.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9715ee260c1a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Engage everyone in your Zoom call using 1–2–4-All]]></title>
            <link>https://s4nchez.medium.com/engage-everyone-in-your-zoom-call-using-1-2-4-all-3d89408e3560?source=rss-67dd819eb35f------2</link>
            <guid isPermaLink="false">https://medium.com/p/3d89408e3560</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[remote-working]]></category>
            <category><![CDATA[facilitation]]></category>
            <category><![CDATA[liberating-structures]]></category>
            <category><![CDATA[collaboration]]></category>
            <dc:creator><![CDATA[Ivan Sanchez]]></dc:creator>
            <pubDate>Wed, 09 Sep 2020 19:24:11 GMT</pubDate>
            <atom:updated>2020-09-09T19:24:11.970Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FilkNEIFuppHV9wOsSFqIw.jpeg" /></figure><p>One of the challenges of running meetings over Zoom is including every single participant. Without some structure, only the most vocal people will share their thoughts, and the whole group will miss the opportunity to hear perhaps the most innovative ideas that may come from quiet people, individual contemplation or smaller conversations.</p><p>We can solve most of these issues using a <a href="http://www.liberatingstructures.com/home/">Liberating Structure</a> called <a href="http://www.liberatingstructures.com/1-1-2-4-all/">1–2–4-All</a>. In this article, I’ll share an adapted way to use this structure with Zoom + Breakout Rooms + any collaborative note-taking tool (e.g. Google Docs)</p><p>The original structure takes around 12 minutes, but I suggest people plan for about 25–35 minutes for its virtual version. That’s to take into account the technical setup, the extra instructions, and the slower transitions between rounds.</p><p>Before you try it for the first time, I recommend getting familiar with Zoom’s Breakout Rooms feature by <a href="https://support.zoom.us/hc/en-us/articles/206476093-Enabling-breakout-rooms">following their tutorial</a> and experimenting with a colleague or two ahead of time.</p><h3>Round #1 — Brainstorm ideas individually</h3><p>We start by supplying time for people to think on their own about the problem at hand.</p><p>For this stage, we must:</p><ul><li>Be clear about the question/topic.</li><li>Invite people to take notes so they can refer back on the next step.</li><li>Remember to put the timer on for 5–7 minutes.</li><li>Mute all participants.</li><li>(bonus) Play some music.</li></ul><p>We can achieve this with the following prompt:</p><blockquote>We’ll start with a moment to reflect individually about the challenge at hand: . Take notes of your ideas so you can discuss them in the next rounds. I’ll put minutes on the clock now, and I’ll mute everyone until it’s time to continue as a group.</blockquote><p><em>Tip</em>: if you’re the only host, you can save time and avoid multitasking by using this time when people are thinking individually to set up the Breakout Rooms for the next round.</p><h3>Round #2 — Generate new ideas as pairs or trios</h3><p>In this round, we’ll use Breakout Rooms to split the group according to the number of participants. We aim to have two or three people in each room.</p><p>For this stage, we must:</p><ul><li>Let people know that they’ll be moved to Breakout Rooms to share and build on their initial ideas.</li><li>Invite people to consolidate their ideas in a collaborative note-taking tool. (e.g. Google Doc or even Zoom’s chat)</li><li>Have the Breakout Rooms ready for the desired number of people.</li><li>Have the shared document for note-taking ready to be shared.</li><li>Remember to put the timer on for 7–10 minutes.</li><li>Send people reminders of how much time they have left.</li></ul><p>We can use the following prompt to get this round started:</p><blockquote>We’ll now move into rooms for pairs (or trios) where we can discuss our initial ideas and generate some new ones. I’ll put the link to a shared document for notes in the Zoom chat. Please consolidate your ideas in a new section with your Breakout Room name. After X minutes, we’ll move back to the main room before moving to the next round.</blockquote><p><em>Tip</em>: Remember to take into account that when you close the Breakout Rooms, Zoom will still give an extra minute for people to finish conversations before moving everyone back to the main room.</p><h3>Round #3 — Develop ideas further in groups of four or six</h3><p>In this final group round, we’ll reuse the existing Breakout Rooms this time for larger groups so people can discuss, develop, and gather the best ideas.</p><p>For this stage, we must:</p><ul><li>Re-assign people to a subset of the Breakout Rooms to form larger groups.</li><li>Invite people to combine their group’s ideas in the collaborative document.</li><li>Remember to put the timer on for 10–15 minutes.</li><li>Send people reminders of how much time they have left.</li></ul><p>It’s useful to explain this round to participants using the prompt:</p><blockquote>Now we’ll get together in groups of four (or six) to develop our best ideas. Please consolidate your output in the shared document in a new section with your Breakout Room name. After X minutes, we’ll move back to the main room for our debrief.</blockquote><h3>Round #4 — Share the most important ideas with everyone</h3><p>Now it’s time to gather the essential ideas created and developed in the prior rounds and share them with the whole group.</p><p>For this stage, we must:</p><ul><li>Allow every group to contribute.</li><li>Make sure we record all relevant insights.</li><li>Capture as many good ideas as possible.</li></ul><p><em>Tip</em>: Don’t throw away the unmentioned ideas from the final round. Instead, invite participants to read them after the session.</p><p>Ask for each group, and repeat for as many times your time allows:</p><blockquote>What is one idea that stood out in your conversation?</blockquote><p>After running all the rounds of 1–2–4-All, you should end up with the best insights the group could produce, some of them revealed by the open, generative conversations that this structure allows.</p><h3>Bonus tips</h3><ul><li>Experiment running multiple rounds of pairs, so people get a chance to interact and generate more ideas.</li><li>For smaller groups, try pre-defining the Breakout Room set up to foster diversity of backgrounds, experiences, and opinions in each room.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d89408e3560" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Eight Behaviours for Smarter Teams]]></title>
            <link>https://s4nchez.medium.com/eight-behaviours-for-smarter-teams-a55371b1b9f9?source=rss-67dd819eb35f------2</link>
            <guid isPermaLink="false">https://medium.com/p/a55371b1b9f9</guid>
            <category><![CDATA[facilitation]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[collaboration]]></category>
            <dc:creator><![CDATA[Ivan Sanchez]]></dc:creator>
            <pubDate>Sat, 08 Aug 2020 09:51:06 GMT</pubDate>
            <atom:updated>2020-08-08T09:51:06.612Z</atom:updated>
            <content:encoded><![CDATA[<p>I’ve recommended “Eight Behaviors for Smarter Teams” by <a href="https://twitter.com/@LeadSmarter">@LeadSmarter</a> so many times that I decided to make a summary of them:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/0*ieNXhJorapsOm-be.jpg" /></figure><p><strong>1. State views and ask genuine questions</strong></p><p>Give context and share your views before asking questions to get better quality of answers.</p><p>Genuine questions come from a place of curiosity. You should avoid leading or rhetorical ones to encourage more productive conversations.</p><p><strong>2. Share all relevant information</strong></p><p>By sharing relevant information, including things that don’t support your point of view or preferred solution, you add to a shared pool of knowledge that the team can use to make better decisions.</p><p><strong>3. Use specific examples and agree on what important words mean</strong></p><p>Try to bring concrete, real-world scenarios to help address challenging issues. And don’t be afraid to check if the words you’re all using mean the same thing to everyone.</p><p><strong>4. Explain reasoning and intent</strong></p><p>The reasoning is your train of thought (logic). The intent is where you’re planning to take it (purpose).</p><p>By sharing those two aspects, you spare people from guessing the meaning of your words and actions, avoiding misunderstandings.</p><p><strong>5. Focus on interests, not positions</strong></p><p>There is usually more than one position that could satisfy people’s interests. By clearly identifying what people care about, you can design and commit to a solution that better meets everyone’s needs.</p><p>My favourite personal variation of “focus on interests, not positions” is “focus on the problem, not the solution”.</p><p><strong>6. Test assumptions and inferences</strong></p><p>We take information from granted (assumptions) and draw conclusions about things we don’t know based on things we know (inferences).</p><p>When you validate those, you create another source of learning and add to the pool of shared knowledge.</p><p><strong>7. Jointly design next steps</strong></p><p>Smart team members avoid deciding things unilaterally. By being transparent and curious, you’ll find yourself involving those who hold valuable information, as well as those who are likely to be affected.</p><p>It may take extra work to jointly decide the next steps, but this pays off in shared understanding and a higher level of commitment.</p><p><strong>8. Discuss undiscussable issues</strong></p><p>Relevant and negative issues are usually emotionally charged; therefore tend to be avoided by most teams. Personal behaviour, performance, or strong opposite positions are typical examples of such matters.</p><p>The good news is that the mechanics of the previous seven behaviours still apply when addressing undiscussable issues.</p><p>The ability to address undiscussable issues early and often is a deciding factor for teams who want to make good choices together.</p><p><strong>Key takeaways</strong></p><p>Smart teams are good at sharing information, learning from each other, and accepting responsibility. They make informed choices as a group and show compassion towards each other.</p><p>Learn more about the Eight Behaviours from the <a href="https://bit.ly/eight-behaviors-roger-schwarz">original paper by Roger Schwarz</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a55371b1b9f9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Two Bold Rules to get meetings right before they even start]]></title>
            <link>https://s4nchez.medium.com/two-bold-rules-to-get-meetings-right-before-they-even-start-12fdbae225ab?source=rss-67dd819eb35f------2</link>
            <guid isPermaLink="false">https://medium.com/p/12fdbae225ab</guid>
            <category><![CDATA[facilitation]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[collaboration]]></category>
            <dc:creator><![CDATA[Ivan Sanchez]]></dc:creator>
            <pubDate>Mon, 27 Jul 2020 19:07:21 GMT</pubDate>
            <atom:updated>2020-07-27T19:07:21.500Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="A collaborative meeting with the doors open" src="https://cdn-images-1.medium.com/max/1024/1*4vvlVgW41BeNWdeS3mC23A.jpeg" /><figcaption>Image credit: <a href="https://unsplash.com/@bantersnaps">@bantersnaps</a></figcaption></figure><p>There aren’t many teams where meetings don’t become a contentious subject at some point or another. Regardless of the topic and even before any meeting takes place, the way a team manages meetings says a lot about how they operate and how invested in self-organisation they are.</p><p>The main contention I see is around attendance: often people feel they’re invited to too many meetings, or that they’ve been excluded from the important ones. Regardless, the responsibility of getting this balance right tends to fall in the hands of one or few team members, and it’s just too easy to get it wrong and create frustrations.</p><p>A way to make this situation a lot better is to embrace two bold and simple rules: <strong>Meetings are open to the whole team, </strong>and <strong>Meetings are always optional</strong>.</p><p>By saying that <strong>Meetings are open to the whole team</strong>, there’s no longer a risk of excluding interested people. It also opens the space for people who otherwise wouldn’t be present to show up and contribute.</p><p>Open meetings also incentivise better invitations (goals, agenda etc) upfront. With those in place, team members will be able to judge if they’ll be able to learn and contribute, and also propose changes to scope or time in case key people can’t attend. It also moves the responsibility of coming up with the attendance list from individuals to the whole team, who’s now empowered to make the best decision possible.</p><p>This flexibility only works if <strong>Meetings are always optional</strong>. This rule creates the safety for people to skip attendance when they judge appropriate, and even apply the <strong>Law of Two Feet </strong>(“it’s ok to leave a meeting if you’re no longer learning or contributing”) when needed. The result is meetings with higher engagement.</p><p>Those two rules are inspired by Open Space Technology and widely applied at conferences, and require a leap of faith. You have to trust that meetings will count with the right people and produce the best outcome possible in each context. And above all, that you trust the team to help each other for that to happen.</p><p>If you believe this could be of benefit to your team, I suggest the following three next steps:</p><ol><li>Share and discuss this article with your team.</li><li>Commit to applying to the <em>Two Bold Rules</em> for 2–4 weeks as an experiment.</li><li>Reflect as a team on the impact, and if possible, share the results with other people who could benefit from it.</li></ol><p><a href="https://dogged-knitter-3175.ck.page/08aa7b87a4">Improve your team interactions</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12fdbae225ab" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deployments vs Releases]]></title>
            <link>https://s4nchez.medium.com/deployments-vs-releases-f6a375fad391?source=rss-67dd819eb35f------2</link>
            <guid isPermaLink="false">https://medium.com/p/f6a375fad391</guid>
            <category><![CDATA[continuous-delivery]]></category>
            <dc:creator><![CDATA[Ivan Sanchez]]></dc:creator>
            <pubDate>Tue, 30 Oct 2018 22:55:20 GMT</pubDate>
            <atom:updated>2018-10-30T22:55:20.101Z</atom:updated>
            <content:encoded><![CDATA[<p>When a team is looking to move towards Continuous Delivery, it comes a time when it’s essential to differentiate <strong>deployment</strong> from <strong>release</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QJRuN68JjmeKn4oICJ-qDA.jpeg" /></figure><p>Traditionally, new versions of the software are built, tested, and made available to users in cycles that vary from once every few days to every few months. In that context, each new version will most likely contain some visible impact to the user, so the words <em>release</em> and <em>deployment</em> tend to be used interchangeably to express when a new version has reached users.</p><p>In recent years, however, many development teams have been focusing on reducing the lead time to <em>deploy</em> any given change down to hours or even minutes. That has been made possible by increasing the focus on automating most of the steps required to verify, assemble and install new versions, as well as increasing the focus on instrumenting and monitoring the software so problems can be spotted and fixed quickly.</p><p>The ability to <em>deploy</em> new versions of the software more frequently means that often a new version of the software doesn’t necessarily contain a visible impact to the user. Those new versions are still worth deploying though, as they represent small, valuable increments, and having the latest version of the software being exercised by users earlier will:</p><ul><li>Help the team learn how their changes behave in production, where it actually matters.</li><li>Make potential problems (and bugs, in general) easier spot to remediate.</li><li>Exercise the tools and procedures used to build and deploy each version.</li><li>Promote a culture of continuous improvement.</li></ul><p>Some examples of small, “invisible” increments that benefit from being deployed as soon as they are ready are security patches, performance improvements, or internal changes to make things simpler to evolve or maintain.</p><p>Being able to <em>deploy</em> sooner also means the team can take advantage of feature flags to hide incomplete features from users until they are ready. During that period, the team may have the ability to enable them for specific users (internal or external) to evaluate how it behaves before it can reach a wider audience. The feature can then be <em>released</em> with greater confidence and at the most appropriate time.</p><p>The splitting of <em>deployment</em> and <em>release</em> may represent a significant shift for those used to longer release cycles. The longer the <em>release</em> cycle is, the more significant are the changes, and higher is the chance of things going wrong. The natural response, in this case, is to be more reluctant to <em>deploy</em> new changes, especially when the new version doesn’t contain something visible to users.</p><p>In reality, <strong><em>deploying</em> more frequently de-risks <em>releasing</em> changes to the users</strong>. That, in addition to the ability to better control when and how changes are made available, should make this approach very attractive to modern software development teams.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f6a375fad391" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning a new codebase from its history beyond the code]]></title>
            <link>https://s4nchez.medium.com/learning-a-new-codebase-from-its-history-beyond-the-code-64de2061592f?source=rss-67dd819eb35f------2</link>
            <guid isPermaLink="false">https://medium.com/p/64de2061592f</guid>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Ivan Sanchez]]></dc:creator>
            <pubDate>Mon, 20 Aug 2018 20:52:08 GMT</pubDate>
            <atom:updated>2018-08-20T20:52:08.373Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the most challenging aspects of learning a new codebase is to understand how things got to be the way they are now. Rather than viewing the current code/documentation as the current representation of reality, I find useful to see them as the result of many internal and external influences over time.</p><p>As developers, we tend to see source control as the official history of a codebase. Unfortunately, just looking at the previous commits, no matter how well organised they are, is barely enough to understand the decisions that shaped the system.</p><p>A better source of this kind of information is <a href="http://thinkrelevance.com/blog/2011/11/15/documenting-architecture-decisions">Architecture Decision Records (ADRs)</a>. When available, those records provide a convenient way to learn about the context where technical decisions were made.</p><p>Recently, I’ve been noticing that looking at those is rarely enough. There are clues about the codebase that go undocumented, and the only source is the memory of existing team members. A critical deadline, a strategic mission that eventually changed, a piece of infrastructure that was not particularly reliable, a part of that team that got moved to another country, or an influential team member who left, are all precious information to paint a complete picture of a software project.</p><p>Drawing together a timeline a whiteboard with the help of existing team members is an excellent approach to surface some of this history. However, I wish that information was readily available at any given point.</p><p>Here are some of the things I wish people documented over time:</p><ul><li>What drove the creation of this project in the first place?</li><li>What was the context of the company at that time?</li><li>Who was in the initial team?</li><li>How has the team structure changed?</li><li>What kind of challenges has the team faced over time?</li><li>What external forces had an impact on the project (positive or negative)?</li><li>Who joined/left the team?</li><li>Who were advocates or champions of specific tools, techniques, and approaches adopted by the team?</li><li>What was the technical context of the original architecture?</li><li>Were there any notable pivots in priorities or goals?</li></ul><p>That kind of information exists for any project, and it should be easy to track it as it happens for future reference. And because it’s factual, it does not require to be kept up to date like an architectural diagram.</p><p>In the last few days, I’ve been talking to <a href="https://twitter.com/natpryce">Nat Pryce</a> about some of these ideas, and he came up with <a href="https://github.com/npryce/pottery">Pottery</a>, a tool similar to his <a href="https://github.com/npryce/adr-tools">adr-tools</a> but intended to “record things that happen in a project”, like an internal Twitter feed. I’m curious to see this kind of approach adopted in the wild and the impact it can have on teams as they evolve.</p><p>Ultimately, learning a new codebase from a project history perspective is helpful beyond the technical sphere: it helps us to connect and empathise with the rest of the team and all the challenges that they have faced so far.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=64de2061592f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>