<?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 John Obelenus on Medium]]></title>
        <description><![CDATA[Stories by John Obelenus on Medium]]></description>
        <link>https://medium.com/@jobelenus?source=rss-1f475fd5666d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*nrEQ7S1EJmgnrAP8sLeNng.png</url>
            <title>Stories by John Obelenus on Medium</title>
            <link>https://medium.com/@jobelenus?source=rss-1f475fd5666d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 10:44:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jobelenus/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[Layers, Complexity, and Trends]]></title>
            <link>https://jobelenus.medium.com/layers-complexity-and-trends-929503929abf?source=rss-1f475fd5666d------2</link>
            <guid isPermaLink="false">https://medium.com/p/929503929abf</guid>
            <category><![CDATA[complexity]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[John Obelenus]]></dc:creator>
            <pubDate>Thu, 15 Oct 2020 17:01:10 GMT</pubDate>
            <atom:updated>2020-10-15T17:01:10.222Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0i5yt4SVAL7bCvuq" /><figcaption>Photo by <a href="https://unsplash.com/@snapsbyclark?utm_source=medium&amp;utm_medium=referral">Clark Van Der Beken</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>There is a short post that I cherish called: <a href="https://ferd.ca/complexity-has-to-live-somewhere.html">Complexity Has To Live Somewhere</a>. Sometimes engineers need to be reminded that if everything was simple, clean, and easy, we wouldn’t be getting paid. It is our job to create the interfaces, the abstractions, and the patterns that place the complexity where it belongs.</p><h3></h3><p>Some examples of accidental complexity: git; managing package.json; all of AWS; editor config; everything in an API that isn&#39;t the result you want; deployment; testing; syntax.</p><p>The truly insidious part about complexity is accidental complexity. To use a metaphor it is: “the cost of doing business.” Accidental complexity is all the other crap that you have to do before you can do what you need to do. There are lots of reasons for accidental complexity; leaky abstractions, tech debt, and technical decisions made before your time.</p><p>I’ve written before how writing software is more of an artisan process than a construction process. And it is because this is still a young immature industry, despite how large and monied it is. We’re still learning how to do this. Humans have been constructing buildings for thousands of years, we’ve figured out a few things and standardized on nearly everything. That said, there are still leaky abstractions and technical debt in construction.</p><p>I live in a house constructed in 1905. This has taught me a lot. Nothing is square, level, or plumb. That said, if you’ve ever walked into new construction-nothing is square level or plumb there either. Over that time there have been decisions and bad work. As an unskilled construction worker, I can get by fixing things in this house. But the true expert, the master of their craft in construction and carpentry, can walk in here and produce work that results in perfection despite what is underneath.</p><p>We aren’t close in the tech to allowing unskilled workers to make real progress. Hell, we’re still trying to help ourselves.</p><p>Most of the startups that cater to other developers are working to eliminate accidental complexity for others by taking it on themselves and asking folks to pay for it. Many open-source projects, I’m looking at you Kubernetes, are designed explicitly for removing this accidental complexity. To band together and try to make managing all the servers in a data center look like managing a single server. You can only reason about things that can fit inside your head. K8s is an operational metaphor that tries to get everything into your head so you can reason about it.</p><p>I look at Lambdas, and messaging services (whether it’s AMPQ or Kafka), and I see the attempt to make a distributed system made up of dozens of CPUs and hundreds of gigs of memory operate as if it was on one system. By making servers “not matter” you can think about your running application as a logic puzzle that runs on one system.</p><p>This is not limited to system design. We do this when we architect our code as well. We create interfaces and patterns that put complexity in the one spot where it is necessary to deal with. And we attempt to wall off each different complexity from one another.</p><p>This is the trend we’ve been on in cloud computing-eliminating anything and everything we can that makes applications <em>look</em> distributed. We don’t always succeed. Just like in construction nothing is level, square, or plumb. When the abstractions leak we need the experts, the master artisans.</p><p>We are trying desperately to do more with less. Fewer engineers, fewer meetings, because those are the most expensive pieces of this puzzle, the network effect born by communicating. I’m not sure we’re succeeding yet, but we’re trying like hell.</p><p><em>Originally published at </em><a href="https://blog.jobelenus.dev/blog/layers-complexity-and-trends/"><em>https://blog.jobelenus.dev</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=929503929abf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Space Required]]></title>
            <link>https://jobelenus.medium.com/space-required-ffceb2059dbf?source=rss-1f475fd5666d------2</link>
            <guid isPermaLink="false">https://medium.com/p/ffceb2059dbf</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[management-and-leadership]]></category>
            <dc:creator><![CDATA[John Obelenus]]></dc:creator>
            <pubDate>Fri, 09 Oct 2020 21:07:08 GMT</pubDate>
            <atom:updated>2020-10-09T21:07:08.512Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*r8ehXU6-3W_vMCXq" /><figcaption>Photo by <a href="https://unsplash.com/@bsm_justin?utm_source=medium&amp;utm_medium=referral">Justin Little</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>There is a unique failure mode that I have experienced: trying too hard. I never saw this one coming, and I never expected it. “Trying too hard” means that you have a tight grip over each aspect of every project. The biggest symptom I have experienced from this failure mode: The Bystander Effect.</p><p>“Bystander effects” are when folks on the team wait for someone to tell them what to do or to make a decision. It is a lack of initiative. The team expects the leader to do all that. And this leader doesn’t have to be a manager or “the boss”, it can be a fellow team member. Trying too hard can result in unexpectedly becoming a gatekeeper. Everything needs their stamp, their confirmation, their inclusion. The team learns “this is how we do things here” and waits.</p><p>If you are seeing bystander effects, and lack of initiative, the antidote is space. Space is required for people to take ownership. Space is required for people to grow. Space is required for people to make improvements, and to improve themselves.</p><p>Creating space looks like putting in guardrails and explicitly stating your expectations. However, space is not a vacuum. It will be rocky at first, and folks will say it feels like a vacuum. Stating expectations is the tool to align everyone’s behavior, this is the hands-off part (e.g. give the problem, and loosely define the process). The guardrails are where you want the team to include you in the process again. That can be varied based on your situation and may include: “if the solution will cost more than $X”, “if the solution will take longer than Y”, or when there are multiple teams and boundaries involved “if the solution requires changes to interfaces or APIs that other teams manage”.</p><p>A good test of whether or not your team is set up for success and owning their own work is: can you go on a two-week vacation and when you return you see progress.</p><p><em>Originally published at </em><a href="https://blog.jobelenus.dev/blog/space-required/"><em>https://blog.jobelenus.dev</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ffceb2059dbf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Choosing What To Problem To Have]]></title>
            <link>https://jobelenus.medium.com/choosing-what-to-problem-to-have-98274e9eedea?source=rss-1f475fd5666d------2</link>
            <guid isPermaLink="false">https://medium.com/p/98274e9eedea</guid>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[John Obelenus]]></dc:creator>
            <pubDate>Fri, 01 May 2020 13:22:54 GMT</pubDate>
            <atom:updated>2020-05-02T18:48:40.646Z</atom:updated>
            <content:encoded><![CDATA[<h3>Choosing What Problem To Have</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*epRvC6DT8MjOh4L6" /><figcaption>Photo by <a href="https://unsplash.com/@olav_ahrens?utm_source=medium&amp;utm_medium=referral">Olav Ahrens Røtne</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Most of our engineering decisions these days are about choosing which problems you want to have. For me, this realization came off the back of the popularization of the CAP theorem. Learning that the natural constraints of a distributed system force you to pick availability or eventual consistency, means you have to choose what problem you want to have. Would you rather your system have slower responses, or even be down? Or, would you rather have data “look… off” for a while, and write rules to manage conflicts, or heaven forbid, manage some manually. While the big players are building for the route of eventual consistency, it is absolutely legitimate to choose availability. This is a thorny, if abstract problem, but choosing your problems exist on smaller scales too.</p><p>A recent example of this for me is dealing with any sort of data de-normalization. There are a lot of engineering choices to make here around transactions, code simplicity and reuse, and managing the cost of compute time. Often times the simplest and easiest to reason about implementation is a standard ETL every X hours. The problem you’ve chosen to have is that for N hours your data is out-of-date. That is another easy problem to explain and understand to people. But, this is not always a viable problem to deal with.</p><p>I love database triggers and procedures for these sorts of operations when the cost of compute is low enough. No matter how many points throughout the code that touch this data, the database is always the commonality, so code-reuse is essentially nil. Putting the operation in the database handles the transaction issue; the original operation is not completed until the trigger finishes. This works well enough when the compute cost is low, when its high you’re going to slow down a high traffic db with locks.</p><p>If you put the ETL operation in a separate re-usable codebase that operates in a different transaction, and the compute cost is high, you have the potential for race conditions based on how you’re kicking off your tasks and guarantees of run-once. Sometimes the constraints of your work chooses the problems you are going to have.</p><p>I see this playing out on the front end as well. I am, apparently, in the minority who thinks that the problems React and its ecosystem brings are not worth the benefit. I do not want and I don’t want my customers to have; giant payloads and big cpu loads (especially for lower end devices). I honestly don’t even think the developer experience is even that good. There are some upsides that have some second order problems: there are tons of components and packages. Like Python, there is a package for whatever you need to do. However, this leaves you a problem to solve: you are going to have to fight against the grain to make it all come together and look the way you actually need. My pet theory is that this is why there are so many front-end jobs. You can pick a template, theme, or even Facebook, Google, or Bootstrap design system and then grab a machete to make it match your brand. That is not a problem I want. The second-order problem is that developers only know how, or want to solve, problems with React. Many have lost track of the underlying things we are trying to solve in the browser, and trying to deliver to the user. This is when people are capable of being blind-sided because they’ve lost the forest for the trees. They never see the next thing coming. And there are lots of possibilities on the front end that don’t include shadow DOMs or JAMstacks. The JAMstack is a great solution to bringing the fastest first-paint to the user by pushing content as far as you can to the edge, which means it has to be static. That is one way to solve sending giant payloads-putting it as close to the user as possible.</p><p>If we aren’t continually paying attention to which problems we are good at solving, capable of solving, as a team, we run the risk of picking a problem that can do some damage, by accident.</p><p><em>Originally published at </em><a href="https://blog.jobelenus.dev/blog/choosing-what-to-problem-to-have/"><em>https://blog.jobelenus.dev</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98274e9eedea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Modals Are The Worst]]></title>
            <link>https://jobelenus.medium.com/modals-are-the-worst-db3d376bc3b2?source=rss-1f475fd5666d------2</link>
            <guid isPermaLink="false">https://medium.com/p/db3d376bc3b2</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[John Obelenus]]></dc:creator>
            <pubDate>Sat, 25 Apr 2020 14:00:27 GMT</pubDate>
            <atom:updated>2020-04-25T14:00:27.149Z</atom:updated>
            <content:encoded><![CDATA[<p>This is my “Hot Take” for the front-end world. I truly think modals are bad. Bad for the end user, and a crutch that too many developers and UX folk rely on.</p><p>Let’s start with the users because they matter most. We have implemented modals to take over the whole screen, to be an interruption, and to hide all content behind it. My challenge for the experience is: replace every modal you have in your application with a browser dialog() call. The only difference is that the dialog locks the main thread-but you&#39;ve already locked the thread in the users mind, so you might as well.</p><p>There have been numerous times where I need other data on the screen in the modal. But I can’t see it, it is hidden behind the modal. And I can’t get to it. And of course, once you close a modal, whatever you did in there is gone.</p><p>Looking at modals on mobile is the nail in the coffin. Due to the screen size it <strong>must</strong> take up the entire screen. What is the difference between that and “navigating to a new page” in the mobile UI metaphor? When you actually navigate to a new screen you get the standard back button right where you expect it, right where it is like every, single, other, application. By using a modal on mobile you’ve confused your user and broken the standard UI metaphor for these devices.</p><p>Using modals is how we developers show our laziness. It is a crutch both in terms of not wanting to do more work in creating new pages (or states), and not wanting to think about how to improve the UI so a modal window is unnecessary. There are lots of possibilities that range from small and unobtrusive like inline editing, or more fundamental like left/right pane splits (e.g. a list on the left, detail on the right). I think we really need to start thinking about task-specific UX where we optimize for what task a user is trying to do. Build a UI specifically for that task. Don’t just throw a modal into the mix because it <em>allows</em> the user to do something. I am willing to bet it is clunky. And if you had the job to use that modal window hundreds of times a day, you would quickly redesign it for something better.</p><p>I think the web would be much improved if ad blockers could block every custom modal window. Add modals to the deny list. There is an up-and-coming HTML &lt;dialog&gt; element, which is a replacement for dialog(). Let&#39;s build toward that, and destroy custom modals. I know people will abuse the dialog to take over the whole window-but it does not have to. And, if it is an HTML element it can be controlled by the browser; there can be system settings to protect users when we developers abuse it. I imagine the possibilities of site-lists that block their use of the element.</p><p><em>Originally published at </em><a href="https://blog.jobelenus.dev/blog/modals-are-the-worst/"><em>https://blog.jobelenus.dev</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db3d376bc3b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Choices: Engineering, Organizations, and Constraints]]></title>
            <link>https://jobelenus.medium.com/choices-engineering-organizations-and-constraints-a0827a35df4e?source=rss-1f475fd5666d------2</link>
            <guid isPermaLink="false">https://medium.com/p/a0827a35df4e</guid>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[organizational-culture]]></category>
            <category><![CDATA[organizational-change]]></category>
            <dc:creator><![CDATA[John Obelenus]]></dc:creator>
            <pubDate>Sat, 04 Apr 2020 16:08:42 GMT</pubDate>
            <atom:updated>2020-04-04T16:08:42.622Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/596/0*htg23uRulb5AP0RY.png" /></figure><p>I have not found a better distillation of the gordian knot that is modern software development. There was a time when one person could, effectively, have the entire computer in their mind and produce good software. That time is long since past. Due to the technical and economic choices we have made, and are living with, we are forced to work together. Michael Feathers is, I think, holding up mob programming as a solution to the problem. I absolutely think it is one possible solution. I think there is at least one other possible solution. The each have their own constraints and I want to walk through them as a thought exercise.</p><h3>Mob Programming</h3><p>What are the constraints around mob programming? Most teams have been doing it in-person. As work moves towards remote teams we are going to lose the high-fidelity of in person communication and bonding as a team. As teams become more distributed across timezones getting people together at the same time is going to be more difficult. As remote participants it is a lot harder to stay focused on people on the other side of a screen than if they were in person. One constraint that remains in place whether it is in person or remote is the increased importance of personalities gelling. Programming can be a very intense mental activity at times, and, to me, it can start to feel like letting someone in your head. You’re going to be with these people for many hours a day-there are going to be interpersonal problems. The makeup of these teams, and management of these issues is crucial for long-term success. Any issues that would have come up in a team that is not mob programming are going to be multiplied by mob programming. These are real constraints that are going to require a lot of effort on the part of people managers. The folks working very closely together are going to need to be fully mature adults capable of managing their own emotions and being socially aware. These two traits are not something we commonly find in certain areas of our industry.</p><h3>One Person Per Service</h3><p>I’m not sure I’ve ever seen someone fully describe what I am about to try and describe. I’m not sure anyone we have all heard of, that I could point to, has done this. I think my principle here is: crystal clear divisions of responsibilities.</p><p>There has been a consistent trend in the industry around best practices of making things smaller, less dependent, and more frequent. One example: make smaller commits that are atomic, and deploy each of them, don’t work for a week on a feature branch, push 100 commits, and have to figure out merge-hell on Friday when you are trying to deploy. A second example is a preference for (responsibly using) microservices over monorepos, the goal has been to create less dependencies and smaller environments. I think I am advocating for that in terms of Engineering Org design as well.</p><p>If software is best when designed by one mind, let one mind be responsible for one service. It’s design, its environment, running it in production. If one mind is going to do this, as I said in the open, it has to be small enough to fit in the head of one mind. I think this fits in with microservices very well.</p><p>What are the constraints around this kind of approach? Communication between these minds becomes the single most important criteria for success. I maintain that we’ve seen an organization do this: Amazon. They removed “insider access” to teams within the company, making everyone rely on documented interfaces to work together. They created an artificial constraint in order to elicit a behavior they wanted. That level of communication is not easy, after all, how many companies and products have good documentation with clear technical writing? Not many (not even Amazon I would argue, it is plentiful, but is it clear?). Another critical issue here is a bus factor of 1. Your internal documentation and code quality has to be very high.</p><p>So what do you do with all the people if there are just going to be single-folks running around? Maybe your bus factor is not 1, maybe its 2, because you pair a more senior engineer with another engineer closer to entry-level. This is a very clear mentorship model, with a clear sponsorship, promotion, and “graduation” experience-you get your own service. (In my experience mentorship situations become difficult when folks don’t recognize they ought to be acting more like a mentor, or more like a mentee.) All these folks with services are going to need underlying building blocks. There are always common elements in any software design. Other people can work on those building blocks, with clear documented interfaces and responsibilities. I can imagine this growing into a structure similar to the way the open-source community operates today.</p><p>Mob programming is an attempt to solve a communication problem. Adopting it creates an artificial constraint: there is only one keyboard, in order to elicit a new behavior: you must communicate to get code written. I think I am merely flipping the situation. My artificial constraint: one person, one service, in order to elicit a new behavior: good written communication.</p><p>I want to embrace remote-first approaches, embrace distributed teams, embrace asynchronous teams. Doing that requires good written communication. You can always ask people to do it, but until its actually required to make progress, you don’t really know what you are going to get.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/583/0*Dtqs8mGqlrVcPF8W.png" /></figure><p>We are all trying to solve the same problem, trying to come up with what works for us. What works for one group, one company, won’t work for another. There is not one way.</p><p><em>Originally published at </em><a href="https://blog.jobelenus.dev/blog/choices-engineering-organizations-and-constraints/"><em>https://blog.jobelenus.dev</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a0827a35df4e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Front-End: Declarative vs Objective-Orientated]]></title>
            <link>https://jobelenus.medium.com/front-end-declarative-vs-objective-orientated-f55a13761456?source=rss-1f475fd5666d------2</link>
            <guid isPermaLink="false">https://medium.com/p/f55a13761456</guid>
            <category><![CDATA[css]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[John Obelenus]]></dc:creator>
            <pubDate>Thu, 26 Mar 2020 16:02:29 GMT</pubDate>
            <atom:updated>2020-03-26T16:02:29.268Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OOcZ0Yu59lH1V11h" /><figcaption>Photo by <a href="https://unsplash.com/@pankajpatel?utm_source=medium&amp;utm_medium=referral">Pankaj Patel</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I’ve always been far more of a programmer than a designer. I don’t think I’ve ever personally liked anything I’ve designed on the web. It’s been good enough, sometimes, and other times not so much. But I find myself squarely on the side of the designers on this one.</p><p>First off, CSS is a programming language. Full stop. If you don’t think so, you’re part of the problem. What designers have been able to do with this declarative programming on the front-end is nothing short of amazing. I’ve written CSS files with hundreds, and even a thousand, lines, that does the same work these masters can do in a tenth as many lines. People like Andy Bell, Heydon Pickering, and many others.</p><p>The React folks of the world have, quite naturally, come to the conclusion that object-oriented encapsulated components are the one true, best, and only way to build designs on the front-end. For logic-that may be true, but for design I think this is patently false. Once you believe this you start writing things like this: <a href="https://mxstbr.com/thoughts/margin">“Margin considered harmful”</a> and making things infinitely more complicated, just to keep the precious components.</p><p>CSS rules are not meant to be encapsulated. Why not? Because it is a declarative language. SQL works the same way. There are absolutely exceptions to the rule where you do want that, but you don’t optimize for exceptions. You allow them to happen. Which CSS does on its own perfectly well. There are certainly things we can do that make it easier on the developer <strong>and</strong> leverage CSS (looking at you Svelte). CSS-in-JS is optimizing for exceptions and breaking CSS in order to have encapsulation.</p><p>Rather than refusing to use only margin (or only padding, or only X) in your CSS components, why don’t you get the CSS out of JS entirely. Learn from the masters about how to use CSS properly.</p><p>CSS is not an object orientated language. So let’s not try and shove it into that box. Not only does it result in poor developer experience that you need to twist yourself into knots, it results in a massive proliferation of rules that both increase the payload size of our applications, and slows down the browser performance.</p><p><em>Originally published at </em><a href="https://blog.jobelenus.dev/blog/front-end-declarative-vs-objective-orientated/"><em>https://blog.jobelenus.dev</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f55a13761456" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Code As Communication]]></title>
            <link>https://jobelenus.medium.com/code-as-communication-72b56491c68a?source=rss-1f475fd5666d------2</link>
            <guid isPermaLink="false">https://medium.com/p/72b56491c68a</guid>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[John Obelenus]]></dc:creator>
            <pubDate>Thu, 20 Feb 2020 15:56:36 GMT</pubDate>
            <atom:updated>2020-02-20T15:56:36.287Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vHZo23XlXNyFfO2X" /><figcaption>Photo by <a href="https://unsplash.com/@yulokchan?utm_source=medium&amp;utm_medium=referral">Joseph Chan</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I’m fond of saying that code has no value until it is running in production. I still believe that is a correct and important statement. But I want to qualify that statement to say that code has no <strong>performative</strong> <strong>value</strong> until it is running in production. No one’s job is complete, its not “done” until its running in prod.</p><p>But there is another value in written code: communication. There comes a time when you have written the one pagers. You’ve written more detailed documentation and plans on what you’re going to do. And you’ve had the meetings to discuss all of these ideas. But sometimes you still don’t have traction with the folks involved. People seem to still not be on the same page. To use an aviation metaphor-you’re trying to take off and there is a lot of drag slowing you down from reaching takeoff velocity.</p><p><em>Start writing code. Don’t even try and run it.</em> Create a draft pull request. Keep writing code and increase your code coverage on the topic. There is <strong>communication value</strong> in non-running code. It can get people past whatever the mental blocks are.</p><p><a href="https://blog.jobelenus.dev/tags/softwareengineering/">#SoftwareEngineering</a><a href="https://blog.jobelenus.dev/tags/leaddeveloper/">#LeadDeveloper</a></p><p><em>Originally published at </em><a href="https://blog.jobelenus.dev/blog/code-as-communication/"><em>https://blog.jobelenus.dev</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=72b56491c68a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Engineering Speed is a Symptom]]></title>
            <link>https://jobelenus.medium.com/engineering-speed-is-a-symptom-a4bd3e8885c5?source=rss-1f475fd5666d------2</link>
            <guid isPermaLink="false">https://medium.com/p/a4bd3e8885c5</guid>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[John Obelenus]]></dc:creator>
            <pubDate>Sun, 02 Feb 2020 02:49:31 GMT</pubDate>
            <atom:updated>2020-02-02T02:51:34.618Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_eNRWBE44B-fIpKP" /><figcaption>Photo by <a href="https://unsplash.com/@harleydavidson?utm_source=medium&amp;utm_medium=referral">Harley-Davidson</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I think the speed of a team is the result of a function, it is the symptom of a working environment. It doesn’t happen by simply standing up and demanding that people work faster. Engineering teams deliver quickly when they have confidence. I don’t mean individual self-confidence, or a level on Maslow’s hierarchy of needs. And I certainly don’t mean the overconfidence of someone’s ego. That function is transferable experience of production systems, that results in engineering speed. A working environment is one that produces this transferable experience in engineers.</p><p>This is what my experience as a Technical Lead has taught me. Each individual has their own baseline, and their own limits. Not everyone shows up to work together starting in the same mental place. And not every company needs the same pace-a seed startup and a publicly traded company need different pieces at different speeds. There are always impediments and roadblocks that slow anyone down. Confidence comes from experience, and the experiences required, I think, are very specific. You know people have the right kind of experience its transferable. That means they come into a new scenario confident-and deliver on that confidence. But first I want to talk about what I believe are red-herrings.</p><p>Here are two things everyone thinks you absolutely need in order to go fast. There is no doubt these things help, but they are not required-that is a myth. Whether you have these or not you still need confidence that comes from experience. Neither of these give you experience or confidence.</p><h3>Tests &amp; CI/CD systems</h3><p>Test coverage is a hotly debated topic. How much should coverage should you have? What does it mean when you have X% coverage? How do you know it is enough, or not enough? How long is too long for your test suite to run before it starts slowing your people and processes down? Unit tests prove one thing, that a highly specific input for an isolated piece of code results in a highly specific output. There is zero doubt that is useful in certain times and places.</p><p>But as the bugs grow the number of test cases grows. As the codebase grows the test cases and the number of bugs grow. That doesn’t sound fast, or that it scales, to me. I’ve seen teams that have a lot of tests and these teams still move slowly, because they aren’t confident in what their system is doing and therefore are unsure how to keep moving forward.</p><p>Having a CI/CD system doesn’t necessarily give you confidence either. It is definitely helpful that the deployment of code is according to a consistent process, if only that it saves a human time and removes some possibilities of human error. It is a tool, just because you use a tool doesn’t mean you’re a confident craftsman.</p><h3>Staging environments that match production</h3><p>Once a system reaches sufficient complexity no other environment can ever match the real live environment. It doesn’t matter if you’ve set it up exactly the same way. It doesn’t have the same traffic, and it doesn’t have the same random collisions of events that are the ones that cause problems in production. I don’t understand why people think they cannot live without a fully-matching-prod staging environment for day-to-day operations. There is no doubt it is useful for certain things at certain times. But staging environments do not bring that much difference from working on your laptop. That is a learning curve that happens pretty quickly during engineering, and then it plateaus. Forever. Therefore staging doesn’t bring confidence.</p><p>These three things are so common I am sure people cannot imagine living without them. Someone who has had these tools ought to be able to live without them. Why? Because their level of confidence isn’t given to them by these tools. At times these tools can help them gain confidence, but it is never the fundamental piece. These tools give you false confidence. You can spot the difference between false confidence: teams still move slowly, and are worried about making changes.</p><h3>We need to understand the reality of our systems</h3><p>There is nothing that is at all like your production system. Nothing approaches behaving like it. The only way to gain the experience that will make you confident is by living in your production system. Unit tests bear almost zero resemblance to production. Poking around with features based on old data on staging is not living in prod either.</p><p>Living in prod means watching users use your system. Whether that is standing over the shoulder of users (if you can be so lucky), or having enough observability to determine what is really happening. Standard monitoring that tells you your P95 is ~200ms is not enough. Outliers matter, because the outliers are real users having real problems that are going to complain about your product on twitter. They are going to stop using it, and stop paying for it one day.</p><p>Living in prod means knowing what your system is actually designed to do, and knowing how it works. I’ve been shying away from high-level abstractions and large dependencies more and more these days. Especially ones I don’t control or deeply understand. The more you understand about the fundamentals of your system the more confidence you’ll have. Who knows when the next left-pad exploit is going to hit your system-make sure you’re depending on things you need, and understand.</p><p>Defensive code that runs in prod is more important than unit tests. As a tech lead I find that I am writing more code to do tasks I’ve done before. Why? I am writing code that is noisy and fast to debug in production because I have a team to support. My job is not to write as much code as I can. Now my job is about communicating and being an example. Communicating examples of failure in production is extremely valuable information for my team. Especially when I may not be the one supporting a particular piece of code in the future.</p><p>The big reason that trunk-based development and continuously shipping small changes are rising in popularity is because when you make small changes you ought to know exactly what should change in your system. And you better be watching your system after you ship to make sure that it changed, and it is the only thing that changed. Observing what you ship brings confidence. Your CI/CD system is pretty useless when you work on long-lived branches and ship a lot of changes at once. Your tool is sitting idle most of the time. That does not instill confidence.</p><p>Confidence is not about intelligence. It is about experience. Usually people get experience through pure time on the ground. But that takes a long time, and plateaus quickly unless that person gets involved in every different part of the org and code. If you put that person in a new place how much of their experience is transferable? Almost none of it, and they quickly lose any confidence they’ve built up.</p><p><em>Originally published at </em><a href="https://blog.jobelenus.dev/blog/engineering-speed-is-a-symptom/"><em>https://blog.jobelenus.dev</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a4bd3e8885c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Own (New) Management Reflections]]></title>
            <link>https://jobelenus.medium.com/my-own-new-management-reflections-a56376b7bbd2?source=rss-1f475fd5666d------2</link>
            <guid isPermaLink="false">https://medium.com/p/a56376b7bbd2</guid>
            <category><![CDATA[management]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[John Obelenus]]></dc:creator>
            <pubDate>Tue, 14 Jan 2020 23:46:01 GMT</pubDate>
            <atom:updated>2020-01-14T23:46:01.105Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_hpi7kJOdvDE20lZ" /><figcaption>Photo by <a href="https://unsplash.com/@noahbuscher?utm_source=medium&amp;utm_medium=referral">Noah Buscher</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I’m nearing the six month mark in my $latestGig, and my role has turned into a product and people management role. I was hoping this would happen, but not before I got to fully build something myself. Such is life, ruining a well formulated plan.</p><p>I’ve done the customer-facing part of Product Management before as a consultant. But this time around I have learned that Product management is as much about getting alignment and agreement within your org about what to build as it is with users. There is less convincing required, but more prodding for the answer to: “And how does this effect you and your department’s plans?” Of course this one runs both ways. Announced changes require getting involved to make sure that your services are still receiving everything they need, especially with new rollouts.</p><p>I haven’t had a chance to manage people yet, and I’m excited for the new challenge. In the short few weeks I’m focused on communicating our team goals for the quarter, establishing expectations, and staying out in front of the team both in terms of toil and getting them all the definition and details they’ll need to keep working without delay.</p><p>Over the last few years I’ve been less and less interested in what happens inside the black box that is the computer. I’ve become far more interested in how much a well-running team can really achieve. I’m interested in what structures you can engineer that are going to change the landscape for your team, department, and customers.</p><p><em>Originally published at </em><a href="https://blog.jobelenus.dev/blog/my-own-new-management-reflections/"><em>https://blog.jobelenus.dev</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a56376b7bbd2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Is My Culture?]]></title>
            <link>https://jobelenus.medium.com/what-is-my-culture-aeb1f7a67b20?source=rss-1f475fd5666d------2</link>
            <guid isPermaLink="false">https://medium.com/p/aeb1f7a67b20</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[culture-change]]></category>
            <dc:creator><![CDATA[John Obelenus]]></dc:creator>
            <pubDate>Thu, 14 Nov 2019 14:33:05 GMT</pubDate>
            <atom:updated>2019-11-14T14:33:05.887Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZGDF9R1Uk-64IMjY" /><figcaption>Photo by <a href="https://unsplash.com/@pimchu?utm_source=medium&amp;utm_medium=referral">Pim Chu</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I just finished Ben Horowitz’s <em>“What You Do Is Who You Are”</em>. I want to focus on the biggest lesson I took from the book about creating your own culture. I sum it up in this way; <strong>there is a specific belief or outlook you have, that others do not, which will determine the level of success of your endeavor.</strong></p><p>It made me ask the question of myself. First off, my general “endeavor” has always been a well-functioning Engineering department, especially regarding “the Product” and Product Management. I admit, this is not the culture of a whole company that is looking to either “change the world” (Ha!).</p><p>I think everyone would agree that “not wasting other people’s time” is an obvious thing we all agree about. However, I don’t think most people actually take it seriously. One example from the book that I appreciate is from Bezos at Amazon. Meetings have agendas. They take the form of a written explanation/argument, it is not merely a set of bullet points. Every meeting starts with silence-while everyone reads the agenda. This also necessitates being on time. If everyone came on time, and was prepared, because they read the agenda beforehand, and learned what they needed to know, and read the agenda again-to get their head in the right spot for the meeting-you can finally have a productive meeting. Making shocking rules around being prepared for meetings, and living by those rules really has the chance to shorten those OODA loops, so you can waste less time as an organization, and have better reactions to the world.</p><p>But what belief do I have that is unique, that others would likely disagree with, that will make a critical difference in these teams performance? If I were to try and put this into words it would come out something like; “ <strong>Build so you can walk away.</strong>” In my career, this has been the defining element of my own success. Over the last ten years, every production system I’ve built, all four of them, are still running. And I’ve walked away from all of them to build the next one. This was absolutely based on a constraint-for three of those projects I worked at a three person company. In order to do more work, we had to stop doing other work. But the software kept running and people used it every day.</p><p>I view this topic as the primary difference in the maturity of the software industry versus other industries. What happens as we continue to work on our software products? We hire more folks, and create more features. More, and more, and more. But, at some point, you need more and more people to even keep up with managing what you’ve created. That is not scaling and does not scale. In other industries, like construction, the size of the crew doesn’t change much. They move from site to site. Once they leave, the building is up and running and, more or less self-maintaining with some basic oversight no where near the level of investment to construct the building.</p><p>Underpinning this belief is an axiom that the most expensive part of any work is the cost of communication. That is why “adding people to an already late project makes it even later.” Will Larsen’s discussion about migrating services also sticks in my head on this topic. When you’re in a growth trajectory your processes and software will be useless roughly every 18 months. Because so much has actually changed on the ground, that what worked at one size, no longer works at the new size. Who are the people most capable of building the new system? The people who are watching the current one fail (assuming everyone is reasonably equal in terms of technical ability). They won’t have the ability to build the next one, if they can’t walk away from the current one. There are many reasons people need to walk away from something, the largest of all is when they leave a job.</p><p>My favorite parts of the book were reading the various “shocking rules” of each of the cultures the book went over. What would my own shocking rule be? How would it enforce my culture of “build so you can walk away”? I’m still working on this, but something along the lines of <strong>a forced vacation or rotation every few months, or after shipping a project</strong>. I’m not sold that is precisely the rule, but, that is what my brain is stuck on right now.</p><p>This has a dynamic similar to the “should we release/deploy on Friday?” question. If I ask you how confident you are in what you’re about to release/deploy, you say “Very confident!” If I said “Great, release it on Friday at 5pm!” would your answer change with the threat of having to work on the weekend if it goes wrong?</p><p>If I told you that tomorrow you will be working on something new, what would happen to your last work? Is there enough documentation for someone to figure out how it works? Are there enough tests so that other people can confidently make changes without worrying they’re going to break the world? How many times a day is someone going to interrupt you with a question that only you know the answer to? How quickly will that exhaust you and mean you can’t actually make progress on the new priority?</p><p>Moving people around regularly can build all these muscles. These muscles are valuable to creating the most value with the fewest number of people. Fewer people means paying less communication tax. That is scaling, not just getting more humans into the building. <strong><em>This process will also create a selection bias of people that are good at communicating.</em></strong> Why? Because I’m forcing them to. I’m forcing them to communicate ahead of time, through writing, through tests, through agendas and meetings, through good design and UX. Someone who stays on the same team, on the same codebase, for a long time, no longer has to communicate, because everything is known to them. And it’s all in their head. How does this data get out? Usually by random osmosis of other people who need data asking random questions. It’s almost never systemic. I want my culture to be one of systemic communication so that you can build something, and walk away from it-knowing that it will keep working, and that others have resources to onboard themselves to it.</p><p><em>Originally published at </em><a href="https://blog.jobelenus.dev/blog/what-is-my-culture/"><em>https://blog.jobelenus.dev</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aeb1f7a67b20" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>