<?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 Tom Elliott on Medium]]></title>
        <description><![CDATA[Stories by Tom Elliott on Medium]]></description>
        <link>https://medium.com/@theotherelliott?source=rss-7c2bf94547e7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ye2sMYCMiWi9EUF_NR2amQ.jpeg</url>
            <title>Stories by Tom Elliott on Medium</title>
            <link>https://medium.com/@theotherelliott?source=rss-7c2bf94547e7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 05:09:36 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@theotherelliott/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[5 Leader”tips” and the Software Engineering Success Summit]]></title>
            <link>https://medium.com/average-coder/5-leader-tips-and-the-software-engineering-success-summit-d2a7ecfac55d?source=rss-7c2bf94547e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/d2a7ecfac55d</guid>
            <category><![CDATA[management]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[leadership]]></category>
            <dc:creator><![CDATA[Tom Elliott]]></dc:creator>
            <pubDate>Tue, 26 Jan 2021 23:43:02 GMT</pubDate>
            <atom:updated>2021-01-26T23:43:02.909Z</atom:updated>
            <content:encoded><![CDATA[<p>Going from Individual Contributor to Manager, I had to learn quickly, and made plenty of mistakes along the way. These are some of the lessons I’ve learned over the past few years, that I hope will help any new or aspiring leaders along their own path.</p><p>This post is a companion piece to a presentation I’m giving at the Software Engineering Success Summit about making your choice between a Technical and a Management career path (more on that later!). Good leadership is essential for any senior member of a team, and these tips will help you boost your effectiveness as a leader no matter which path you choose.</p><h3>Don’t Do Everything Yourself</h3><p>A large part of leadership is convincing, prodding or flat out telling people to do things. This takes a certain amount of overhead, be it putting work into a ticketing system, scheduling a kick-off meeting, or just the time taken to explain your ideas. I’ve often found myself getting frustrated at the pace, and been tempted to just do the work myself.</p><p>This is a trap.</p><p>You only have so many hours in the day, and by delegating tasks to your team, they can act as a force multiplier so your overall impact can greatly increase. With a little patience, and careful stewardship, that great idea you just have will be done before you know it.</p><p>Including your team also gets more minds working the problem, and may bring forth ideas you’d never consider, which brings us to…</p><h3>Let Your Team Surprise You</h3><p>Some of the most satisfying experiences I’ve had as a leader have been when a member of my team surprised me by exceeding my expectations. When you have deadlines to meet, it can be tempting to assign the work to the people who have the best chance of completing the work on time and to the highest level of quality.</p><p>This approach to scheduling can result in some unfortunate side effects. Knowledge about a particular service can become siloed with the subject matter expert who is always doing the work on it, resulting in an unacceptably low <a href="https://en.wikipedia.org/wiki/Bus_factor">“bus factor”</a>. An undue amount of pressure could be placed on more experienced or high-performing members of the team, so the reward for doing good work is…more work. Worst, the avenues for growth and advancement narrow, and you could lose junior members of the team who don’t feel challenged or encouraged.</p><p>Try to stretch people every once in a while. Have them work on a new area of the product, or take on a task that’s new to them. Hold back on giving all the answers up front and give people an opportunity to develop their own solutions. You need to balance this with support and a safety net in case things don’t work out, but if you give people a chance to surprise you, more often than not they will!</p><h3>Do What You Say You’ll Do</h3><p>In his <a href="https://www.youtube.com/watch?v=O8Hx4tFW4PU&amp;list=PLBzScQzZ83I-CMMW3_ULONRHVToeCBJqf&amp;index=8">talk at LeadDev Austin in 2019</a>, Spencer Norman said “Be the kind of leader that does what you say you’re going to do”. This advice struck a chord with me, as it touches on so many of the interactions and expectations we have as leaders. If you ask your team to do things, you better be setting an example of meeting your own commitments. If you promise to do something to help out a report, but don’t follow through, they might feel you don’t have their back.</p><p>I’ve found that following through on promises is mostly a game of keeping track of them. Luckily, there are so many tools out there to help. My go-to is currently the <a href="https://support.google.com/docs/answer/65129?co=GENIE.Platform%3DDesktop&amp;hl=en">comment assignment feature</a> in Google Docs. Since all my meeting agendas and notes are in Google Docs, I can quickly set myself tasks without a context switch. Not only that, but searching in Google Drive for <a href="https://drive.google.com/drive/search?q=followup:actionitems&amp;usp_dm=true">followup:actionitems</a> will show you a list of all your assigned items. I make a habit of setting aside a few hours a week to work through them.</p><p>Sometimes a task will be more time-sensitive. In that case, I’ll make sure to block off a specific time in my calendar to work on it. Even if I don’t end up doing it exactly during that time window, I’ve got a stark reminder right in front of me all day.</p><h3>Give Credit</h3><p>Nothing worse than having someone else claim credit for your work. The worst kind of leader is one who claims someone else’s achievements as their own. A great leader is one who elevates the people they lead, making sure they are appropriately lauded and rewarded for their efforts.</p><p>As a leader, everyone else’s work reflects on you, so if you’re giving credit for people going above and beyond, it makes your team and yourself look good as well.</p><p>Not only that, but frequent feedback is crucial to help your reports learn and grow. Both positive and constructive feedback. A common piece of advice is to “praise in public, criticize in private”. So if someone does something great, let them and others know, let them enjoy it, and they’ll be encouraged to repeat the experience or go even further next time.</p><h3>Talk To Your Peers</h3><p>When you start leading people, your peers are no longer your team, but leaders doing the same job as you. Believe it or not, they’re probably having very similar problems as you are, even if it’s not obvious from the outside.</p><p>When I first started leading a team, I mostly learned by emulating what I’d seen my own managers do, which left out a lot of the detail and nuance. Even worse, when I encountered new situations, I wasn’t sure how to handle them.</p><p>One Friday afternoon, as teams were finishing up their retro meetings and people were gathering for a well earned drink, I found myself in a circle of relatively new tech leads and managers. The longer we talked, the more we realized we were facing the same kind of problems in getting used to the role.</p><p>Shortly after, we organized monthly “huddles” to discuss these issues and share our ideas and learnings about leadership and management. This not only helped us feel more comfortable with the role, but led to a number of ideas and techniques being proliferated amongst the various teams, like common templates for goal setting and “questions of the week” for 1:1s.</p><p>You don’t even need a full blown programme of meetings to connect with your peers. Many of your peers would be willing to have a monthly 1:1 meeting with you, even if it becomes a purely social occasion.</p><h3>The Software Engineering Success Summit</h3><p>I’ll be presenting these ideas and others at the <a href="https://www.swesuccess.com/swe-success-summit?affiliate_id=2885833">Software Engineering Success Summit</a> on February 8th.</p><p>For 4 days, (Feb 8–11), Sam Gavis-Hughson of <a href="https://www.byte-by-byte.com/"><em>Byte by Byte</em></a> is bringing you presentations from 15+ industry experts to show you how to transform your career into the career of your dreams. You’ll hear about everything from interview preparation to career development, and more.</p><p>For example, I’m going to be talking all about your choice between a Management and a Technical track to build a career you’ll find most rewarding!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aSH901TDTlR9cegXkAkXLA.png" /><figcaption>Software Engineering Success Summit: February 8–11 2021</figcaption></figure><p>We’re featuring some pretty big names, including:</p><ul><li>Professor Brian W. Kernighan (co-creator of K&amp;R C)</li><li>Chris Castiglione (founder of OneMonth)</li><li>And a whole lot more!</li></ul><p>The best part? <em>It’s totally free!</em></p><p>Check out all the details here: <a href="https://www.swesuccess.com/swe-success-summit?affiliate_id=2885833">Get your free ticket for the Software Engineering Success Summit today!</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d2a7ecfac55d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/average-coder/5-leader-tips-and-the-software-engineering-success-summit-d2a7ecfac55d">5 Leader”tips” and the Software Engineering Success Summit</a> was originally published in <a href="https://medium.com/average-coder">average-coder</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can you use GitHub Actions for Monitoring?]]></title>
            <link>https://medium.com/average-coder/can-you-use-github-actions-for-monitoring-e9c6cfe79ef4?source=rss-7c2bf94547e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e9c6cfe79ef4</guid>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[sre]]></category>
            <dc:creator><![CDATA[Tom Elliott]]></dc:creator>
            <pubDate>Sat, 01 Aug 2020 20:48:14 GMT</pubDate>
            <atom:updated>2020-08-01T20:48:14.065Z</atom:updated>
            <content:encoded><![CDATA[<p>Short answer: <strong>you could, but you really, really shouldn’t</strong>.</p><p>I’ve been playing around with <a href="https://github.com/features/actions">GitHub Actions</a> a lot recently, and I’ve found it to be remarkably powerful, matching all but a few of the features from dedicated CI providers, and with a <a href="https://github.com/pricing">generous free tier</a>, particularly for open source repos.</p><p>While working through the <a href="https://docs.github.com/en/actions/reference/events-that-trigger-workflows#scheduled-events">workflow trigger docs</a>, I noticed that you could set up a job with a cron schedule that triggers every 5 minutes. This is incidentally the same frequency offered by <a href="https://uptimerobot.com/">Uptime Robot</a> for free. Which got me wondering if it was possible to use Actions for monitoring a website’s uptime.</p><p>In theory, you could create a Workflow that was triggered every 5 minutes and hit a URL with <em>curl</em>, failing the job if the request failed or returned an invalid status code. Downtime would then be represented as a failing test, with e-mail notifications built right into the platform.</p><p>But would this be a reasonable substitute for a dedicated, for-purpose monitoring solution?</p><p>The first concern that came to mind was the reliability of Actions. If builds failed for spurious reasons, you might stop paying attention when got a real failure notification. Related to this was the latency between jobs. If you wanted a job to run every 5 minutes, would it actually be running every 5 minutes?</p><p>To test this reliability, I set up a repo with a workflow that recorded the epoch time to a file every 5 minutes.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b566007e88b44cf934982a1cf57bfde8/href">https://medium.com/media/b566007e88b44cf934982a1cf57bfde8/href</a></iframe><p>I left this running for 11 days (I had planned on just 7, but got distracted). During this time there were 2150 runs of the workflow, and 2147 times recorded. There were three spurious failures, only one of which corresponded to an Actions incident on the <a href="https://www.githubstatus.com/">GitHub Status</a> page. This is about a 99.87% success rate, pretty decent.</p><p>Downloading the list of recorded times, and dropping them into a spreadsheet, a plot of the <em>duration between recorded runs</em> showed something surprising.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qw-RJ4aOohdWU3U699tSMA.png" /><figcaption>Chart of times between action runs over 11 days</figcaption></figure><p>The majority of runs were separated by a little over 5 minutes, as expected, but a decent number were delayed up to 20 minutes, with regular spikes of over 40 minutes. All in all, less than 20% of runs were started within 6 minutes of the previous one, and only 88% started within 10 minutes.</p><p>The 40 minute spikes all seemed to occur at midnight UTC, which suggests to me that there is some kind of maintenance task being performed at this time that will delay new jobs from running.</p><p>Irregular sampling and predictable 40 minute windows without any monitoring at all is certainly not going to give confidence in your uptime metrics. And it’s kind of unreasonable to expect otherwise, since Actions wasn’t designed for this. When you’re running CI, these kinds of delays are annoying, but acceptable, especially when you’re getting it super cheap, if not free, and sharing resources with countless other developers.</p><p>But just in case you’re thinking of some clever ways to work around this, perhaps with long-running jobs and complex leader-election mechanisms to hand over control from one job to another, there are some other, more obvious drawbacks.</p><p>Using Actions in this way degrades your experience in the GitHub UI, clogging your activity feed with mention of every time the workflow updates its records:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8TOXBJUkFdDJOEwIRJfulw.png" /><figcaption>My GitHub activity log filled up with references to Actions commits</figcaption></figure><p>Finally, and crucially, it’s very likely against the <a href="https://docs.github.com/en/github/site-policy/github-additional-product-terms#5-actions-and-packages">terms of service</a>.</p><blockquote>Actions should not be used for:<br>…<br>serverless computing;<br>…<br>any other activity unrelated to the production, testing, deployment, or publication of the software project associated with the repository where GitHub Actions are used.</blockquote><p>It could be argued that monitoring is considered “production” or “testing”, but I wouldn’t want to risk having my monitoring discontinued, in worst case with zero notice.</p><p>GitHub Actions is a CI tool. If you’re thinking of using it for any use cases other than CI, you should probably stop and look for purpose-built alternatives.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e9c6cfe79ef4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/average-coder/can-you-use-github-actions-for-monitoring-e9c6cfe79ef4">Can you use GitHub Actions for Monitoring?</a> was originally published in <a href="https://medium.com/average-coder">average-coder</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Audiobook Review: The Unicorn Project]]></title>
            <link>https://medium.com/average-coder/audiobook-review-the-unicorn-project-dd4079b30672?source=rss-7c2bf94547e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd4079b30672</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[audiobooks]]></category>
            <category><![CDATA[book-review]]></category>
            <dc:creator><![CDATA[Tom Elliott]]></dc:creator>
            <pubDate>Sun, 15 Mar 2020 20:24:46 GMT</pubDate>
            <atom:updated>2020-03-15T20:24:46.019Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/338/1*cIBU4UwNMKqrItvY5e4Q1A.jpeg" /><figcaption>Cover of the Unicorn Project, by Gene Kim</figcaption></figure><p>The Unicorn Project is Gene Kim’s follow up to 2013’s The Phoenix Project, which I <a href="https://medium.com/average-coder/audiobook-review-the-phoenix-project-9bb27ded2825">reviewed a couple of years ago</a>.</p><p>I’ve re-read the original a few times since my original review, and it’s given me a little something new every time. Now that my job is much more “DevOps-y” than it was in 2018, I was very excited to read a sequel. For the most part, it didn’t disappoint, and I might even have gotten more out of this book than the original!</p><h3>The Story</h3><p>The Unicorn Project takes place in parallel to the Phoenix Project, during the same period of transformation at Parts Unlimited. A disclaimer early on indicates that some aspects of the story have been altered to take account of changes in the industry and daily life in the intervening 6 years (the rise of Uber and Lyft, new DevOps tooling, etc). However, this by itself was not as jarring as it might have been.</p><p>The story follows Maxine, a developer who is exiled to the Phoenix Project as a direct result of the payroll outage that begins both books. She quickly sets to work trying to get a build of Phoenix working, but quickly discovers mountains of bureaucracy and technical complexity standing in her way, and indeed every developer on the project. She joins with like minded developers to lead a charge to make the experience from test to deployment faster and easier for all, applying a number of best practices, and learning along the way.</p><p>The book stays mostly separate from The Phoenix Project, with few, if any scenes in common. This keeps the book fresh and interesting, and serves to demonstrate that it wasn’t Bill’s (the original protagonist) efforts alone that transformed the company. This does take a little bit of the jeopardy away from the original, but also highlights that transformation cannot come from one person alone.</p><p>The only aspect of the shared timeline I wasn’t entirely sold on were a few touches that seemed more like “fan service”. The sage-like board member dispensing advice in the first novel is introduced in a way that feels very forced, when there could have been many opportunities to do this more naturally.</p><p>Similar to the first book, the epilogue seems a little self congratulatory, although with more emphasis on the contributions of the whole team, which served nicely to tone things down.</p><p>Despite these issues, I found it to be a gripping listen and I was eager to get out for my daily run so I could find out what happens next. It’s not often that an audiobook will take up my attention to such a degree!</p><h3>Lessons</h3><p>A lot of the issues raised in the book are things that my current workplace does very well. We deploy many times a day, and our teams are reasonably autonomous, avoiding a lot of handoff when trying to get things done.</p><p>But in every big problem presented in The Unicorn Project, I was often seeing a little problem or the potential for one in how we do things.</p><p>Much of The Unicorn Project is devoted to establishing the <a href="https://dzone.com/articles/announcing-the-unicorn-project-availability-of-fir">Five Ideals</a>, similarly to the Three ways from the first book. This ideals represent a series of problems that businesses need to solve to produce an innovative, culture where learning and rapid improvement are the norm. In addition to these ideals, the book also addresses concepts such as <a href="https://www.executestrategy.net/blog/mckinseys-three-horizons-of-growth">McKinsey’s Horizons of Growth</a> and <a href="http://strategictoolkits.com/strategic-concepts/core-and-context/">Core vs Context</a> activities.</p><p>In addition to these concepts, a number of learnings are prevalent in the course of the story, such as:</p><ul><li>Red tape is frustrating on all sides, and empathy will get you a long way.</li><li>The more teams are involved in accomplishing single task, the slower it will go.</li><li>Working your team as hard as possible will only reduce your capacity later.</li></ul><h3>Where to Get It</h3><p>Published by <a href="https://itrevolution.com/">IT Revolution Press</a>, The Unicorn Project is available on <a href="https://www.audible.com/pd/The-Unicorn-Project-Audiobook/B0812C4NC9?pf_rd_p=1bcbcf4a-338d-4f9f-9fb9-7c5b66bf627d&amp;pf_rd_r=X64PE734MH6MTE01TX7P&amp;ref=a_author_Ge_c19_lProduct_1_4">Audible</a>, <a href="https://www.amazon.com/Unicorn-Project-Disruption-Redshirts-Overthrowing/dp/1942788762/ref=sr_1_1?keywords=the+unicorn+project&amp;qid=1556552054&amp;s=gateway&amp;sr=8-1">Amazon</a> and all other major e-book sources. A full list is available on the <a href="https://itrevolution.com/the-unicorn-project/">official page</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd4079b30672" width="1" height="1" alt=""><hr><p><a href="https://medium.com/average-coder/audiobook-review-the-unicorn-project-dd4079b30672">Audiobook Review: The Unicorn Project</a> was originally published in <a href="https://medium.com/average-coder">average-coder</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to test your Go packages with GitHub Actions]]></title>
            <link>https://medium.com/average-coder/how-to-test-your-go-packages-with-github-actions-ee784aca2dcf?source=rss-7c2bf94547e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee784aca2dcf</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Tom Elliott]]></dc:creator>
            <pubDate>Sun, 12 May 2019 21:24:26 GMT</pubDate>
            <atom:updated>2019-05-12T21:24:26.319Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://github.com/features/actions">Actions</a> are a GitHub feature — currently in beta — that allows you to add workflows to your repositories to execute automated tasks (such as CI/CD) on each commit. In this post, we’ll see how to set up a workflow to execute unit tests in a Go package.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SWt7rvaehlZ8tN8fGVJTRw.png" /><figcaption>Gopher meets Octocat</figcaption></figure><p>Your workflows are executed within Docker containers, so you can configure Actions with any tooling required. Actions can also be made available to the community via <a href="https://github.com/marketplace">GitHub Marketplace</a>. Helpfully <a href="https://cedrickring.dev/">Cedric Kring</a> has already provided an <a href="https://github.com/cedrickring/golang-action">Action for Go builds</a>, so we can use this to get going.</p><p>You can define your workflows using the GitHub web UI, or by creating the config files manually. We’ll be doing the latter. To add a workflow to your repository, create a file called .github/main.workflow with the following contents:</p><pre>workflow &quot;Unit Tests&quot; {<br>  resolves = [&quot;cedrickring/golang-action@1.3.0&quot;]<br>  on = &quot;push&quot;<br>}<br><br>action &quot;cedrickring/golang-action@1.3.0&quot; {<br>  uses = &quot;cedrickring/golang-action@1.3.0&quot;<br>}</pre><p>This defines a workflow called “Unit Tests” that executes on every push, and runs the action <em>cedrickring/golang-action </em>at version 1.3.0.</p><p>Commit and push this change. You will now see an indicator next to your commits to show the result of running your Workflow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DPFROYKBRxWwFzHKCyfMDA.png" /><figcaption>Successful workflow execution on latest commit</figcaption></figure><p>These indicators also appear with pull requests.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zev5bw0ES-fAviXa24iJUg.png" /><figcaption>Failed workflow execution on pull request</figcaption></figure><p>This is just scratching the surface of what you can do with Actions, but getting started couldn’t be easier! To find out more, take a look at the <a href="https://developer.github.com/actions/">documentation</a> on developer.github.com.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee784aca2dcf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/average-coder/how-to-test-your-go-packages-with-github-actions-ee784aca2dcf">How to test your Go packages with GitHub Actions</a> was originally published in <a href="https://medium.com/average-coder">average-coder</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[An unexpected effect with Go Slices]]></title>
            <link>https://medium.com/average-coder/an-unexpected-effect-with-go-slices-e6347e960633?source=rss-7c2bf94547e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e6347e960633</guid>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Tom Elliott]]></dc:creator>
            <pubDate>Thu, 04 Apr 2019 01:08:39 GMT</pubDate>
            <atom:updated>2019-04-04T01:08:39.393Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cQy6YZv_P-_Qn5NxdtWG8w.jpeg" /><figcaption>A different kind of slice. Specifically, quiche.</figcaption></figure><p>Go’s slices can be pretty powerful, providing an array-like construct that can be dynamically re-sized at will, and grown in a reasonably memory efficient manner via <em>append</em>. But this comes with a few little surprises.</p><p>For example, there’s this little snippet:</p><pre>s := []int{1, 2, 3}<br>s2 := append(s[:2], 4)<br>fmt.Println(s)<br>fmt.Println(s2)</pre><p>You might expect this to output:</p><pre>[1 2 3]<br>[1 2 4]</pre><p>But what you actually get is:</p><pre>[1 2 4]<br>[1 2 4]</pre><p>Feel free to play around with this in the <a href="https://play.golang.org/p/xd2UDX7R-FE">Go Playground</a>.</p><p>What happens here is that the sub-slice we take with <em>s[:2]</em> stays in the same place in memory as the original slice. They’re actually just two separate references to the same underlying array.</p><p>When we then append to this sub-slice, the append operation has no idea that the original slice extends slightly beyond the second. The sub slice has a size of 2, but a capacity of 3 (the underlying array), so <em>append</em> can add a single element without having to grow the array-which would require copying everything to somewhere else in memory.</p><p>If we modify the append to add two elements:</p><pre>s2 := append(s[:2], 4, 5)</pre><p>We no longer have enough additional capacity and need to create a whole new copy of the array with more headroom. So making the above change results in the two slices pointing to distinct arrays and leaves <em>s</em> untouched.</p><pre>[1 2 3]<br>[1 2 4 5]</pre><p>This is a small gotcha, but can easily cause a lot of confusion when working with complex objects. I came across this in the wild when rendering a <a href="https://github.com/robfig/soy">soy template</a>, which added a whole other layer of confusion. It certainly tested my assumptions!</p><p>There’s a lot more about the ins and outs of Go’s slice implementation on the <a href="https://blog.golang.org/slices">Go Blog</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e6347e960633" width="1" height="1" alt=""><hr><p><a href="https://medium.com/average-coder/an-unexpected-effect-with-go-slices-e6347e960633">An unexpected effect with Go Slices</a> was originally published in <a href="https://medium.com/average-coder">average-coder</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Disagree and Commit]]></title>
            <link>https://medium.com/average-coder/disagree-and-commit-ba48706d6519?source=rss-7c2bf94547e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba48706d6519</guid>
            <category><![CDATA[management-and-leadership]]></category>
            <dc:creator><![CDATA[Tom Elliott]]></dc:creator>
            <pubDate>Thu, 28 Feb 2019 02:18:27 GMT</pubDate>
            <atom:updated>2019-02-28T02:18:27.201Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*42gORHTAfnTCZ67Tc6x3SA.jpeg" /><figcaption>An “efficient” line, apparently</figcaption></figure><p>I was out getting lunch today, and something happened that got me thinking about how we deal with decisions we don’t like.</p><p>I was in Pret, grabbing a wrap between meetings, and walked in right in the middle of the lunchtime rush. The line was just about reaching the door, but moving reasonably quickly. One of the staff was trying to direct people to form separate lines, one per cashier. Most people were reluctant, one was downright reticent.</p><p>“Five lines, please, there’re five cashiers.”</p><p>“That’s inefficient”</p><p>“I’m sorry?”</p><p>“Having separate lines is inefficient. One line is better. There have been studies.”</p><p>At this point, another guy in the line chimed in. “He’s first, I’m next.”</p><p>The staffer was unimpressed and she ignored him, turning back to the first complainer.</p><p>“It’s just what Pret want us to do.”</p><p>“Well you tell your manager that it’s inefficient.”</p><p>In the meantime, I’d joined a line and got served before both of them. Everyone further behind was stuck. Regardless of whether or not the guy was right (one line was certainly not fitting into the space very well), his refusal to go along with the queueing decision made by the company did nothing but delay him, most of the people behind him, and annoy someone who had no real power — and likely no desire — to change the decision.</p><p>This put me in mind of a concept that I was introduced to recently: “<a href="https://en.wikipedia.org/wiki/Disagree_and_commit">Disagree and Commit</a>”. It’s ok to disagree with a decision and still go along with it. Not everyone will agree every time, so if you’re in the minority, express your view, then move on.</p><p>Put everything you have into making the decision made work, without complaining, dragging your feet, or trying to sneak your idea in without anyone noticing.</p><p>Otherwise, you’re just an opinionated jerk slowing down the sandwich line.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba48706d6519" width="1" height="1" alt=""><hr><p><a href="https://medium.com/average-coder/disagree-and-commit-ba48706d6519">Disagree and Commit</a> was originally published in <a href="https://medium.com/average-coder">average-coder</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[On “How to Win Friends & Influence People”]]></title>
            <link>https://medium.com/average-coder/on-how-to-win-friends-influence-people-204208015b08?source=rss-7c2bf94547e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/204208015b08</guid>
            <category><![CDATA[book-review]]></category>
            <category><![CDATA[self-improvement]]></category>
            <dc:creator><![CDATA[Tom Elliott]]></dc:creator>
            <pubDate>Thu, 31 Jan 2019 17:00:53 GMT</pubDate>
            <atom:updated>2019-01-31T17:00:53.729Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/608/1*s1xyqUpt7Gup3d-K0XtyKA.png" /><figcaption>One of the many covers from various reprints of the book</figcaption></figure><p>I just finished listening to the <a href="https://www.audible.com/ep/title/?asin=B002V5BV96&amp;source_code=GO1GBSH09091690EI&amp;device=d&amp;ds_rl=1262685&amp;ds_rl=1263561&amp;ds_rl=1260658&amp;cvosrc=ppc.google.how%20to%20win%20friends%20and%20influence%20people&amp;cvo_campaign=250472289&amp;cvo_crid=272802232029&amp;Matchtype=e&amp;gclid=Cj0KCQiA1sriBRD-ARIsABYdwwGEEt_oQGEPwX3esLiheeNsnmRNuoVzKI5nj3cKAq6s6xYgZpowyGMaAuE-EALw_wcB&amp;gclsrc=aw.ds">Audible version</a> of Dale Carnegie’s <em>How to Win Friends &amp; Influence People</em> and it’s been quite the read!</p><p><em>How to Win Friends &amp; Influence People </em>could be considered the quintessential self-help book and has become something of a cultural touchstone. I’m sure most people have heard of it, even if only because of <a href="https://en.wikipedia.org/wiki/How_to_Lose_Friends_%26_Alienate_People_(memoir)">numerous</a> <a href="https://en.wikipedia.org/wiki/How_to_Lose_Friends_%26_Alienate_People_(memoir)">books</a> with <a href="https://en.wikipedia.org/wiki/How_to_Talk_Dirty_and_Influence_People">parody</a> <a href="https://en.wikipedia.org/wiki/How_to_Make_Friends_and_Influence_People">titles</a>. My reading of late has had something of a people skills and management theme, so this felt like a must read.</p><p>There are some really good ideas here, like focusing on what the other person wants when negotiating, taking an interest in them first to make them feel important, and giving people you lead a reputation to live up to.</p><p>Granted, this is quite an old book — the first printing was in 1936, which left me in some confusion over just how long Mr Carnegie lived, since later reprints added references to Stevie Wonder. Being so old, it contains has some rather outdated concepts around family structures and a view on mental health that is now downright uncomfortable. Still, the majority of content is still relevant and shining the values of the past on today’s events can give them a new meaning.</p><p>The book is divided into sections with clear goals in mind, and a set of principles aimed towards achieving each wider goal. Consuming via an audiobook made it easy to lose one’s place in the lists of principles, so I may recommend getting a written copy over the audio version. If you’re feeling particularly extravagant, you could get a written copy as a supplement to the audio. For a less expensive, and perhaps more convenient refresher, the principles are also <a href="https://en.wikipedia.org/wiki/How_to_Win_Friends_and_Influence_People">listed on Wikipedia</a>.</p><p>There was a feeling I found difficult to shake throughout, which was that some of the ideas feel a bit, manipulative. One story in particular stood out, a tale of criticizing oneself to soften potential criticism from others, in this case, to get away with breaking a leash law. A later discovery that Charles Manson <a href="https://www.bloomberg.com/news/articles/2013-07-22/charles-mansons-turning-point-dale-carnegie-classes">used the book</a> to manipulate women into committing murder did nothing to lessen this feeling.</p><p>Overall, though, I got a lot from this book. And will endeavor to use these new found powers only for good.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=204208015b08" width="1" height="1" alt=""><hr><p><a href="https://medium.com/average-coder/on-how-to-win-friends-influence-people-204208015b08">On “How to Win Friends &amp; Influence People”</a> was originally published in <a href="https://medium.com/average-coder">average-coder</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Detecting cycles: safer JSON marshaling in Go]]></title>
            <link>https://medium.com/average-coder/detecting-cycles-safer-json-marshaling-in-go-60e71a95903b?source=rss-7c2bf94547e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/60e71a95903b</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[json]]></category>
            <dc:creator><![CDATA[Tom Elliott]]></dc:creator>
            <pubDate>Wed, 26 Sep 2018 19:20:14 GMT</pubDate>
            <atom:updated>2018-09-26T19:20:14.007Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Il9Lo8AGWHrAYjfpCOc_rw.jpeg" /><figcaption>A large number of cycles</figcaption></figure><p>JSON marshaling/unmarshaling in Go is a very powerful feature, but there are limits to the Go structures that can be marshaled. Most of these limits will trigger an error, but having a cycle in your data structure <a href="https://play.golang.org/p/ShW9i5O4tle">results in a nasty stack overflow</a>:</p><pre>runtime: goroutine stack exceeds 250000000-byte limit<br>fatal error: stack overflow<br><br>runtime stack:<br>runtime.throw(0x1131e3, 0xe)<br>	/usr/local/go/src/runtime/panic.go:616 +0x100<br>runtime.newstack()<br>	/usr/local/go/src/runtime/stack.go:1054 +0x9a0<br>runtime.morestack()<br>	/usr/local/go/src/runtime/asm_amd64p32.s:366 +0xc0<br><br>goroutine 1 [running]:<br>reflect.Value.Field(0x1025c0, 0x1040a0d0, 0x199, 0x0, 0x0, 0x0, 0x0, 0x0)<br>	/usr/local/go/src/reflect/value.go:780 +0x1a0 fp=0x184c0340 sp=0x184c0338 pc=0xb1740<br>encoding/json.fieldByIndex(0x1025c0, 0x1040a0d0, 0x199, 0x10414054, 0x1, 0x1, 0x21140, 0x6e27, 0x10f4a0, 0xf9560)<br>	/usr/local/go/src/encoding/json/encode.go:834 +0x40 fp=0x184c0380 sp=0x184c0340 pc=0xe4cc0<br>encoding/json.(*structEncoder).encode(0x104462e0, 0x1045a000, 0x1025c0, 0x1040a0d0, 0x199, 0x100)</pre><pre>// *** many more lines of this, until *** //</pre><pre>	/usr/local/go/src/encoding/json/encode.go:653 +0x60 fp=0x184c1ad8 sp=0x184c1ab8 pc=0xed1c0<br>...additional frames elided...</pre><p>Because the stack is cut off, these crashes can be extremely difficult to debug in a complex application, particularly if you’re composing together data from many different sources. In such cases it would be useful to be able to identify when there is a cycle, and then be able to see where it is in the structure.</p><p>I encountered a bug like this yesterday, and spent hours trying to pin down exactly where the cycle had been inserted. In the end, I put together a package to check for and helpfully print out the location of such cycles: <a href="https://github.com/theothertomelliott/acyclic">github.com/theothertomelliott/acyclic</a></p><p>Extending the <a href="https://play.golang.org/p/ShW9i5O4tle">example</a> from earlier, we can check for cycles early to allow us to error out before hitting the panic.</p><pre>package main</pre><pre>import (<br>  &quot;encoding/json&quot;<br>  &quot;fmt&quot;<br>  <br>  &quot;github.com/theothertomelliott/acyclic&quot;<br>)</pre><pre>func main() {<br>  value := &amp;struct {<br>    A string<br>    B interface{}<br>  }{<br>    A: &quot;a string&quot;,<br>  }</pre><pre>  // Add a cycle<br>  value.B = value</pre><pre>  // Check for the cycle<br>  err := acyclic.Check(value)<br>  if err != nil {<br>    fmt.Println(err)<br>    return<br>  }</pre><pre>  // With a cycle, we don&#39;t try to marshal<br>  _, _ = json.Marshal(value)<br>}</pre><p>The above code will output an error with the path to the cycle.</p><p>What if we want to see more detail on where the cycle is? Or we have more than one cycle? We can print the structure to see the cycles:</p><pre>acyclic.Print(value)</pre><p>This will output the structure with all cycles replaced with a helpful marker:</p><pre>*{<br>  A: &quot;a string&quot;<br>  B: &lt;CYCLE&gt;<br>}</pre><p>Once I applied this to my original stack overflow issue, I found that I’d been using the wrong variable name when inserting into a map. A problem so obvious I just couldn’t see it when reading the code. Being able to see exactly where the cycle was in the structure allowed me to fix the problem in less than a minute.</p><p>There are <a href="https://github.com/golang/go/issues/10769">differing opinions</a> on whether or not Go should provide a more helpful message here, and the overflow may be improved in a future version. But for now, checking for cycles when marshaling (or printing) complex structures can save you a lot of time and frustration!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60e71a95903b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/average-coder/detecting-cycles-safer-json-marshaling-in-go-60e71a95903b">Detecting cycles: safer JSON marshaling in Go</a> was originally published in <a href="https://medium.com/average-coder">average-coder</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to debug a running Go app with VSCode]]></title>
            <link>https://medium.com/average-coder/how-to-debug-a-running-go-app-with-vscode-76e3eac45bd?source=rss-7c2bf94547e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/76e3eac45bd</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[vscode]]></category>
            <dc:creator><![CDATA[Tom Elliott]]></dc:creator>
            <pubDate>Mon, 17 Sep 2018 18:34:40 GMT</pubDate>
            <atom:updated>2018-09-17T18:38:34.955Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NOuzpW4mgguDAsUQVN_lVQ.png" /><figcaption>Debugging Go in VSCode</figcaption></figure><p>VSCode is a great editor for Go, providing a variety of helpful features to save you time while coding. It also includes support for debugging Go programs in-editor. While this is a very handy feature, I’ve not been making as much use of it as I might, since my testing workflow usually involves launching a group of microservices at once from the command line (sometimes in containers), rather than one-offs in an IDE.</p><p>Often, I want to be able to just connect to one of these processes I already have running to quickly inspect what is happening under the hood. Fortunately, you can do this with a little extra work and some command-line trickery.</p><h4>Pre-requisites</h4><p>You will need to have installed <a href="https://code.visualstudio.com/">VSCode</a> and the official <a href="https://github.com/Microsoft/vscode-go">Go extension</a>. Detail on how to do this is beyond the scope of this post, but the Readme for the extension has a great set of instructions.</p><p>You will also need to install <a href="https://github.com/derekparker/delve">Delve</a>, a debugger for Go. I’d recommend following the up-to-date <a href="https://github.com/derekparker/delve/blob/master/Documentation/installation/README.md">manual installation steps</a> for your OS. I tried using Homebrew initially and had a number of issues, the<a href="https://github.com/derekparker/delve/blob/master/Documentation/installation/osx/install.md#manual-install"> manual steps for macOS</a> worked first time.</p><h4>1. Configure your project</h4><p>The first time you debug your application, VSCode will create a configuration for you automatically, which can then be edited easily.</p><p>Open your main.go file, then select the <a href="https://code.visualstudio.com/docs/editor/debugging#_debug-view">debug view</a> and press the play button at the top of the screen. This will start up a new instance of your application in the debugger.</p><p>Feel free to play around if you’ve not used the debugger before. Set some breakpoints, step through some code. But this just gets a new instance of your application debugging, we want to be able to do this for something we’re running separately.</p><p>Running the debugger will have created a new file in your workspace at <em>.vscode/launch.json</em> that looks something like this:</p><pre>{<br>    // Use IntelliSense to learn about possible attributes.<br>    // Hover to view descriptions of existing attributes.<br>    // For more information, visit: <a href="https://go.microsoft.com/fwlink/?linkid=830387">https://go.microsoft.com/fwlink/?linkid=830387</a><br>    &quot;version&quot;: &quot;0.2.0&quot;,<br>    &quot;configurations&quot;: [<br>        {<br>            &quot;name&quot;: &quot;Launch&quot;,<br>            &quot;type&quot;: &quot;go&quot;,<br>            &quot;request&quot;: &quot;launch&quot;,<br>            &quot;mode&quot;: &quot;auto&quot;,<br>            &quot;remotePath&quot;: &quot;&quot;,<br>            &quot;port&quot;: 2345,<br>            &quot;host&quot;: &quot;127.0.0.1&quot;,<br>            &quot;program&quot;: &quot;${fileDirname}&quot;,<br>            &quot;env&quot;: {},<br>            &quot;args&quot;: [],<br>            &quot;showLog&quot;: false<br>        }<br>    ]<br>}</pre><p>We need to make a few changes to this to make it ready for remote debugging. First off, the mode will need changing to “remote”. We can also get rid of some of the lines that just use default values.</p><p>A <em>remotePath</em> matching the <em>program</em> value is also recommended by some documentation, but I’ve found it isn’t strictly necessary for this process. We’ll include it here for safety.</p><p><em>${fileDirname}</em> is a <a href="https://code.visualstudio.com/docs/editor/variables-reference">predefined variable</a> referencing the directory containing the file you’re currently editing. For simple projects, this will also be the binary name for your application. With more complex projects, you can set this to ${workspaceFolder}, or the full path to your binary.</p><p>When you’re done, you should have something like this:</p><pre>{<br>    &quot;version&quot;: &quot;0.2.0&quot;,<br>    &quot;configurations&quot;: [<br>        {<br>            &quot;name&quot;: &quot;Launch&quot;,<br>            &quot;type&quot;: &quot;go&quot;,<br>            &quot;request&quot;: &quot;launch&quot;,<br>            &quot;remotePath&quot;: &quot;${workspaceFolder}&quot;,<br>            &quot;mode&quot;: &quot;remote&quot;,<br>            &quot;port&quot;: 2345,<br>            &quot;host&quot;: &quot;127.0.0.1&quot;,<br>            &quot;program&quot;: &quot;${workspaceFolder}&quot;,<br>    }<br>    ]    <br>}</pre><p>Your project is ready to go, so let’s start your application.</p><h4>2. Start your application</h4><p>This is the easiest step, just start your application as you normally would. You just need to have a note of where your binary can be found.</p><h4>3. Find the PID and attach Delve</h4><p>We now need to launch Delve in headless mode, listening on port <em>2345 </em>(the default for the debug configuration in step 1).</p><p>Delve needs to know the PID of our application’s process to attach. We can use <a href="https://linux.die.net/man/1/pgrep">pgrep</a> to find this. Since pgrep will return only the PID, we can use, we can evaluate that as part of our command in most shells. So we can start Delve with:</p><pre>dlv attach --headless --listen=:2345 $(pgrep FILENAME) PATH</pre><p>Where <strong>FILENAME</strong> is the name of our application’s binary file (the command that is running), and <strong>PATH</strong> is the path to the copy of the binary we’re currently running.</p><p>This will start a Delve server attached to our running application. You should see some output from Delve along the lines of:</p><pre>API server listening at: [::]:2345</pre><p>Delve is now ready for VSCode to connect!</p><h4>4. Start debugging</h4><p>If you go back to the debug view in VSCode and click the play button to start debugging, VSCode will now connect to your running Delve server. You can use breakpoints and step through code in the same manner as if VSCode had started a new instance itself.</p><p>The only real difference is that stopping debugging will not stop the application that it attaches to (in some circumstances it will stop Delve, though). This means that you can attach to the same process multiple times during its lifecycle.</p><h4>Enjoy!</h4><p>Remote debugging of existing processes is certainly a little more involved than the default workflow, but for those times you need it, may be an invaluable tool in your belt. If containers are a big part of your workflow, you could likely even adapt these steps to always have a debug port open on your test containers.</p><p>Certainly beats adding a bunch of logging lines!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76e3eac45bd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/average-coder/how-to-debug-a-running-go-app-with-vscode-76e3eac45bd">How to debug a running Go app with VSCode</a> was originally published in <a href="https://medium.com/average-coder">average-coder</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Thoughts on a Decade of Blogging]]></title>
            <link>https://medium.com/average-coder/thoughts-on-a-decade-of-blogging-76551b396770?source=rss-7c2bf94547e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/76551b396770</guid>
            <category><![CDATA[blogging]]></category>
            <category><![CDATA[writing]]></category>
            <dc:creator><![CDATA[Tom Elliott]]></dc:creator>
            <pubDate>Sun, 26 Aug 2018 02:11:10 GMT</pubDate>
            <atom:updated>2018-08-26T02:11:10.436Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oQDA0DtgG5xJ8IVJBz8JmQ.jpeg" /><figcaption>A depiction of pre-internet blogging</figcaption></figure><p>I just realized that I passed my 10 year blogging anniversary this month. My first post on<a href="https://telliott.io/"> The Other Tom Elliott</a> was early August of 2009. It really doesn’t seem that long. In that time, I’ve made some <a href="https://telliott.io/node/11">less than stellar attempts</a> at humor posts, reported on <a href="https://telliott.io/node/199">stand up gigs</a> (not done that in a while), and finally settled on mostly technical posts.</p><p>I’ve also moved my blogs several times. From <a href="https://telliott.io/2015/07/21/how-i-migrated-from-wordpress-to-jekyll.html">Wordpress to Jekyll</a>, and now over to <a href="https://medium.com/average-coder">Medium</a>.</p><p>Granted, I’ve had some breaks. Including for most of 2017 and over the whole of 2013. But I’ve still managed to put out enough content to learn some things. Here’s a few learnings I took away from the whole experience.</p><h4>Making things public is a great motivator</h4><p>In the interest of giving myself things to write about, I posted some New Years Resolutions for myself over 2009, 2010 and 2011. The <a href="https://telliott.io/node/113">first year’s goals</a> got me to try stand up, SCUBA diving and fun runs. Later years pushed me to write a (frankly awful) novel about dating, do some volunteering and climb a mountain — which revealed my fear of heights.</p><p>Setting goals and making them public is an excellent way to motivate yourself, and gives you a certain amount of accountability. It’s easy to try to hide your ideas and projects until they’re “ready”, but if you let people know what you plan to do, you might be more likely to do it. Plus, you may get some help along the way that you weren’t expecting.</p><h4>Problem Solving Posts are Popular</h4><p>By far the most popular post I’ve written is one about <a href="https://telliott.io/node/78">recovering lost recordings in GarageBand</a>. Largely because the title of that particular post is pretty much exactly what people would have Googled when they had this problem.</p><p>Searchability aside, writing about problems you’ve solved for yourself is a great way of keeping track of that information for yourself, even if nobody else ever has the same problem. I was hugely surprised to run into an obscure <a href="https://telliott.io/node/860">internationalization bug</a> involving the Turkish language a second time about a year after writing it. The second time, it was pretty easy to solve, since I had all the details written down.</p><h4>Writing nothing is worse than writing something imperfect</h4><p>As mentioned above, I’ve often gone long stretches without writing anything. A lot of the time, I find it hard to come up with a topic that’s “good enough” to write about. This is a habit I need to get out of.</p><p>I’ve written a lot of blog posts that I don’t think are very high quality, but I don’t feel bad about keeping them up. I never know when they might be useful to someone else. I feel a whole lot worse when I don’t write anything at all for a while.</p><p>Here’s to the next ten years. Hopefully I’ll be writing a whole lot more.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76551b396770" width="1" height="1" alt=""><hr><p><a href="https://medium.com/average-coder/thoughts-on-a-decade-of-blogging-76551b396770">Thoughts on a Decade of Blogging</a> was originally published in <a href="https://medium.com/average-coder">average-coder</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>