<?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 Helton Moraes on Medium]]></title>
        <description><![CDATA[Stories by Helton Moraes on Medium]]></description>
        <link>https://medium.com/@heltonbiker?source=rss-32350f2d3fa9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*VK0o9mYhPcL-WG_Sd50-yA.jpeg</url>
            <title>Stories by Helton Moraes on Medium</title>
            <link>https://medium.com/@heltonbiker?source=rss-32350f2d3fa9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 21:17:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@heltonbiker/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[Problem-push vs. Solution-pull in software development]]></title>
            <link>https://medium.com/@heltonbiker/problem-push-vs-solution-pull-in-software-development-e333a1cf14a2?source=rss-32350f2d3fa9------2</link>
            <guid isPermaLink="false">https://medium.com/p/e333a1cf14a2</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[uncle-bob]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Helton Moraes]]></dc:creator>
            <pubDate>Sun, 02 Oct 2016 03:44:58 GMT</pubDate>
            <atom:updated>2016-10-02T13:42:05.070Z</atom:updated>
            <content:encoded><![CDATA[<p>There is a relatively well-known concept of <a href="https://en.wikipedia.org/wiki/Technology_push"><em>technlogy-push vs. market-pull</em></a><em> </em>regarding innovation models. With a <em>technology push</em> model, a company that is fluent in a given technology — say, plastic injection — would find out which products it can produce, and what would be its targeted market segmentation. On the other hand, a <em>market-pull</em> model would be followed by a company commited to a given market segment — say, medical devices, or bicycles — and as such would have to look for suitable technologies to provide the products or services for that market.</p><p>Being a self-taught software developer with just a handful of years in the business, I have noticed a similar <em>push vs pull</em> pattern related to how software developers work.</p><p>I work at a small company that manufactures medical diagnostic devices, and I have a cross-discipline background in healthcare, engineering and design. I started to program after realizing that, if our products contained software, then programming was part of our core business. I learned to program while already at the company, I am self-taught, and programming has always been but an instrument to get our products done. Of course, as the projects went by, I felt the need to increase the level of professionalism of our programming practice, and asked the company owners to hire a “real”, professional developer to help me. It took a while, but the day eventually came.</p><p>It was a marvelous experience at first: now I had a peer! I had something with whom I could take very technical conversations about the sort of programming minnutiae that I had no one to talk about so far. My knowledge about the tools and frameworks and syntax and idioms quickly jumped to a much higher degree. Everything was excellent. Until we had a rather drastic philosophical clash, which I wasn’t expecting at all. While choosing the partitioning of the solution into projects and namespaces, I said: “It’s not about the solution. It’s about the <em>problem</em>!”</p><p>My coworker, a very commited, experienced, intelligent, honest, hard-working developer, had an immense difficulty in understanding <em>why the hell</em> I would’nt follow all the well-established framework-related naming conventions for folders, namespaces, class names, you name it, and instead insisted on creating names that would be unfamiliar to any other developer, since they were related only to <em>that specific application</em>.</p><p>A few days ago, I watched <a href="https://www.youtube.com/watch?v=Nsjsiz2A9mg">an excellent video from Uncle Bob</a>, based on the keynote “Architecture: the Lost Years”. He was complaining that every Ruby on Rails project had a folder structure similar to this (image taken from <a href="http://t.co/TNl0pY72">the keynote file for that lecture</a>):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/909/1*CIpvecs_FTXA5shP7BOZ4A.jpeg" /></figure><p>This was <em>exatcly </em>the type of naming convention that my coworker was trying to sell me as the “right way” to organize the codebase if I expected anything professional, convention-abiding, readily understandable, something that would make any seasoned developer feel immediately at home. (we don’t use Ruby, but you got the idea)</p><p>And then I saw no less than Uncle Bob complaining about <em>exactly the same things that bother me</em>, the same things that created the “gritting of the minds” situation with my otherwise irreproachable coworker.</p><p>In Uncle Bob’s opinion, which I completely agree, the top-level structure of a software project should <a href="https://8thlight.com/blog/uncle-bob/2011/09/30/Screaming-Architecture.html"><em>scream</em> what the application is all about</a>, the same way that if we see the annotated floor plans of a church, or a library, or a slaughterhouse, or a hospital, it should be immediately obvious what’s the intended use of the place. The fact that it was built with a given toolset, or a given technique, should be irrelevant, architecture-wise.</p><p>But I think there is one more step to take about all this. What Uncle Bob is saying is “I don’t want to see the tools, I want to see the <em>solution.</em>” What I am saying is: “I don’ want to see <em>only </em>the solution, I want to see the PROBLEM!”. Like I said above, it’s not about the solution. It’s about the problem.</p><blockquote>But hey, are we not supposed to build <em>solutions?</em> Why do you have this fixation with the problem after all?</blockquote><p>Well, <a href="https://www.youtube.com/watch?v=TMuno5RZNeE">in another of his lectures</a>, Uncle Bob explains why Dependency Inversion is so important, even revolutionary. He actually explains that it is the only really new thing that Object Orientation gave us. And that is because it allows us to <em>decouple</em> the flow of dependency and the flow of control. We can, using dependency inversion, have a system with a dependency structure completely independent from its control flow structure, and that is a key point in having a good architecture.</p><p>I believe the same kind of insidious coupling happens with software development — or more specifically, with software <em>developers</em>. Many software developers see their profession as the ability to write code with a given toolset of languages, IDEs and frameworks, and offer this ability to potential employers, so that these employers can build their software products and solve their business needs and the needs of their clients.</p><p>Let’s be mean and compare the developer to a woodworker. If we need something made of wood, we call a woodworker, tell him what we need, and he will build it. The characteristics of the final product are of our greatest interest, and that’s what we specify. But that is incidental to the woodworker, because what matters to him is woodworking, and the tools of woodworking, and the techniques of woodworking. That is the essence of his profession, and that’s what he cares about, and that’s what he prepares for.</p><p>But that generates the sort of problem Uncle Bob and I complain about. Developers end up trying to make the problem fit the solution. That’s the definition of what I called the <em>solution-pull</em> model. And then the final product structure end up being determined by the tools used to make it. But we want to “see” the the solution, not the tool. I go further: I want to see the <em>problem</em>, not the solution. Any newcomer to the project, independently of what language or framework he’s familiar with, should look at the system, <em>at any level of abstraction</em> (packages, namespaces, classes, methods, variables) and see what is the <em>problem</em> being solved by the application.</p><p>Of course, there is (or at least should be) a very tight coupling between a problem and its solution(s), and that is a good thing. That means satisfying Uncle Bob’s imperative — the architecture should scream <em>“Solution!”</em> instead of <em>“Tool!”</em> — would usually be enough to understand the problem being solved. But that’s incidental. Remember: it’s not about the solution, it’s about the problem!</p><p>There is a <a href="https://en.wikipedia.org/wiki/Law_of_the_instrument">saying</a> that “If you give some boy a hammer, he will find that everything he encounters needs pounding.” This is called the “Law of the Instrument”, and it seems to be sorely prevalent in software development. It’s like when we use MS Word to create a document, and it has a strong tendency to <em>look</em> (actually <em>scream</em>) like it was made in Word. The same goes for Power Point by the way.</p><p>If we use a <em>solution-pull</em> development model, we end up leaving every application with the looks of our tools. Even if problems have quite unique characteristics, the tendency would be that every application more or less looks the same, uses the same underlying concepts, does not describe its own particular structure well, and worst of all, loses the opportunity for an optimal design, tailored for its specific needs.</p><p>I believe the technical skills and the content of the toolbox of a professional developer should not be so coupled to the way he implements the solution of a problem that it stamps its edges all over the final product. I don’t want to look at the final system and see scratch marks all over. The use of the tools <em>must be invisible</em> in the final product — or at least must not be the dominant aspect.</p><p>It’s a lot like decoupling the control structure and the dependency structure in the example above. They <em>tend </em>to be coupled because it’s the natural thing to do if we don’t see a reason to make them different. But after we see the benefits of dependency inversion, and because polymorphism allows us to invert dependencies, we are better advised to do that— at least dependencies we want to avoid.</p><p>In the same way, it’s often times natural for developers to make the problem fit the solution, specially if ther is a certain “universal” solution structure, usually dictated by the culture of a given language/IDE/framework. But I think this is bad. I think <em>the problem should determine the structure of the solution</em>, and never the opposite. I think we should, as much as possible, develop a solution in a way that decouples the characteristics of the tools we use, and the characteristics of the problem we are solving. By using a <em>problem-push</em> architectural model, we both get a solution that fits better to the underlying problem, and avoid leaving our finished work full of inelegant tool scratch marks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e333a1cf14a2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Issues do GitHub — um recurso que vale mais do que parece.]]></title>
            <link>https://medium.com/@heltonbiker/issues-do-github-um-recurso-que-vale-mais-do-que-parece-42c557f9dea0?source=rss-32350f2d3fa9------2</link>
            <guid isPermaLink="false">https://medium.com/p/42c557f9dea0</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[portuguese]]></category>
            <category><![CDATA[version-control]]></category>
            <dc:creator><![CDATA[Helton Moraes]]></dc:creator>
            <pubDate>Tue, 29 Mar 2016 00:23:15 GMT</pubDate>
            <atom:updated>2016-03-29T00:23:15.992Z</atom:updated>
            <content:encoded><![CDATA[<p>Faz pouco tempo que comecei a usar o GitHub no trabalho. Depois de alguns anos sofrendo com o SVN hospedado no servidor local da empresa, um novo desenvolvedor conseguiu “nos convencer” a migrar para o Git, por ser um sistema melhor, e para a nuvem, devido a vários problemas de disponibilidade que começaram a interferir terrivelmente no nosso pair-programming remoto.</p><p>Eu fui o mais fácil de ser convencido a fazer isso, porque já tinha lido bastante, e porque já tinha “upado” algumas coisas pra lá, dos meus projetos de hobby. O fato é que eu nunca tinha tido usado “seriamente” o GitHub para os projetos pessoais, um pouco por falta de insistência, falta de disciplina minha, e por não haver uma real necessidade. O projeto acabava virando uma bagunça de qualquer forma, e o Dropbox acabava sendo a melhor forma de eu ter “sempre a última versão” entre diferentes máquinas. É o típico caso em que eu sabia que o certo era usar direito um sistema de controle de versão, mas não tinha razões suficientes para vencer a preguiça.</p><p>Pois o fato é que desde que começamos a usar o GitHub como uma equipe, para desenvolvimento “sério”, e em especial por estarmos pagando — e portanto querendo espremer todo o suco da laranja — resolvi ir um pouco mais além e explorar todas as outras coisas que a plataforma GitHub (e não necessariamente o Git) oferece. E, por haver uma necessidade de gestão, as Issues se mostraram surpreendentemente úteis.</p><p>Tão úteis que resolvi começar a usar também para os projetos pessoais, e a surpresa é que, mesmo sem ser “desenvolvimento sério”, mesmo sem ser trabalho em equipe (ao menos não por enquanto), eu percebi que, <em>simplesmente por estar usando as issues</em>, o desenvolvimento teve um ganho de qualidade e produtividade absurdo!</p><p>O que notei de mais marcante é que, juntamente com a facilidade do branching, as issues são a forma ideal de registrar uma direção desejada para o desenvolvimento<em> no momento e no contexto em que é adequado fazer isso. </em>E esse momento definitivamente <strong>não </strong>é enquanto se está escrevendo código.</p><p>O hábito que adquiri rapidamente, e que está dominando a forma de desenvolver agora é:</p><ol><li>Assim que eu tenho um momento “ahá!”, e me dou conta de qual é o principal obstáculo ou feature faltando, eu corro pra abrir a issue e escrever em detalhes qual é a natureza do problema: qual a situação desejada, qual a situação atual, quais os passos necessários para transformar a situação atual na situação desejada, e quais os prováveis obstáculos para isso;</li><li>Esse issue deve quase que <em>obrigatoriamente</em> se transformar em uma branch;</li><li>Enquanto eu estiver nessa branch, eu <em>não posso mexer em outra coisa!</em> Manter um histórico “limpo” e evitar a diluição do esforço requer que, numa branch, eu só trabalhe no tema da branch (que deve estar apropriadamente capturado pelo nome escolhido para ela);</li><li>O maior sonho de quem está trabalhando numa branch que não seja <em>dev </em>ou<em>master</em> deve ser terminar a implementação o mais rápido possível, para que a branch possa ser <em>apagada</em> imediatamente após sua conclusão.</li></ol><p>Fazendo isso, temos vários elementos positivos, que somados têm um impacto muito relevante na velocidade e qualidade:</p><ul><li>O fato de um Issue ser criado via browser, com uma interface afastada do código-fonte, leva o desenvolvedor a pensar de forma global e abstrata sobre o problema, em um momento em que o “emocional” não está comprometido com as dificuldades de criação ou implementação. Essa<em>dissociação</em> entre o pensar e o agir fazem com que cada uma dessas etapas seja desacoplada da outra, tornando-se comparativamente mais fácil;</li><li>Ter um par, formado por um Issue e sua Branch correspondente, leva o desenvolvedor a manter o <em>foco</em> naquela funcionalidade específica, e ter um critério definido de “pronto” gera um incentivo palpável e uma sensação de progresso que são muito motivantes;</li><li>A necessidade de isolar as modificações para evitar regressão durante o merge faz com que se privilegie soluções coesas e desacopladas.</li></ul><p>Da próxima vez que você der uma visitada no seu repositório, experimente brincar com as Issues — e em especial brinque também com as Labels e Milestones. Garanto que vai se surpreender com o retorno!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=42c557f9dea0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>