<?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 Arturo Jiménez on Medium]]></title>
        <description><![CDATA[Stories by Arturo Jiménez on Medium]]></description>
        <link>https://medium.com/@napalmdrivendev?source=rss-fbb38d625dd1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*OMU3xxJIVp3179dG8aJ3RA.jpeg</url>
            <title>Stories by Arturo Jiménez on Medium</title>
            <link>https://medium.com/@napalmdrivendev?source=rss-fbb38d625dd1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:46:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@napalmdrivendev/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[Giving valuable constructive feedback on your Code Reviews]]></title>
            <link>https://medium.com/inside-freenow/giving-valuable-constructive-feedback-on-your-code-reviews-457ffb2592f?source=rss-fbb38d625dd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/457ffb2592f</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Arturo Jiménez]]></dc:creator>
            <pubDate>Thu, 04 Jul 2019 07:29:52 GMT</pubDate>
            <atom:updated>2019-07-04T07:29:52.444Z</atom:updated>
            <content:encoded><![CDATA[<p>Code reviews are used to improve code quality and benefit from positive effects on team and company culture. On the internet we can find a wealth of material regarding different aspects of it like how much time to review, how many lines of code to read, checklists to make sure every code-wise topic is covered…</p><p>In this post, I’d like to focus in one important part of this process. <em>The human one</em>. Since we’re giving feedback about our peers work, I think it’s important enough to spend some time talking about how to do it in the most assertive way possible, in order to reduce not only potential code-related problems but also people ones too.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*Kclzh2XdIi8_X993" /></figure><h3>Be problem-focused and specific</h3><p>Instead of telling someone <em>what</em> he has to/should do, explain <em>why</em>. Let’s say your comment was “You need to use the veryGood function, not the veryBad one”. This comment assumes everyone involved in the project shares your level of knowledge about it. Be clear about what the actual problem is and structure your feedback around it, so you will be not only helping to fix this specific issue but also contributing to grow the knowledge and independence of your teammates.</p><p>Have always in consideration: the more specific you can make your feedback, the more actionable it will be.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*zOaoxcvHe8m2lvhU" /></figure><h3>Focus on the situation, not the individual</h3><p>Let’s explain it by using an example: One of your colleagues creates a pull request (PR) and there is no description. To make everything worse, there is only a huge commit without a message and a non-descriptive title. You can attack him, because this is a <em>“known”</em> bad practice, and most likely engage in a pointless ego-battle which only affects the team in a negative way. The other option is discussing the situation itself, rather than just providing your personal opinion about it. This will show you’re more interested in <em>fixing the problem</em> rather than blaming anyone. Impartial observations prove to be more useful.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*0oWjnYAfKJte7RTZ" /></figure><h3>Give praise and recognition</h3><p>We are always harder on the code of everyone else than on ours. Weaving some positives among the negatives or simply complimenting when it’s deserved can be a good way to keep everyone <em>motivated</em> and inspire the ones with less technical knowledge to grow.</p><p>One example could be a simple “I love what you did here. However, we’ve to take care of this other part because…”. This way we can fight the frustration of only receiving critics about our code, which will go in favor of overall motivation knowing only certain aspects of their work need attention.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/227/0*hIEuSPyG8KZC9oVb" /></figure><h3>Show respect</h3><p>Respect for the person’s <em>dignity</em> is the root of constructive criticism. Choose words carefully and try to avoid displaying negative emotions such as anger, sarcasm or disappointment. Select those that do not put the receiver on the defensive. Use messages like “I’ve noticed” or “I’m concerned about” rather than <em>“you”</em> messages, like “you always” or “you never”.</p><p>Be careful with the gif you want to put in your comment, they can easily lead to misinterpretation or show negative emotions (as commented before). This can send a mixed message, confusing or even making the recipient feel humiliated.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/292/0*BO6tS1ajuVHNsZK_" /></figure><h3>Learn to listen</h3><p>Give a chance to respond, so you show that you are prepared to <em>listen to other people’s concerns</em> and interpretations. Expressing their ideas are making them, most likely, become part of the solution.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*hhwNh1-8cd5BEf25" /></figure><h3>Async communication</h3><p>It may look easier and quicker to just answer a comment in the PR face-to-face instead of taking some time for organizing your ideas and writing it down. This information is not <em>visible for the rest of the team</em>, which can be expecting a reply from you on the PR in order to proceed with it or just need to have more info about it. Transparency can always go in favor of knowledge sharing and technical growth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/0*wIYrYQ2h7pXBOtOa" /></figure><h3>Summary</h3><p>Since we are providing feedback about the work made by another person, we should keep as respectful and assertive as possible. Engaging in negative emotions can led us to discuss about the individual rather than the situation and creating unnecessary conflicts that, for sure, are not going to help us improve code or work environment quality.</p><h3>Interested in joining one of our teams as we grow?</h3><p>If you’d like to join us on the journey of designing the future of mobility have a look at some of the roles <a href="https://free-now.com/de/career/jobs/">we’re looking for here</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=457ffb2592f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/inside-freenow/giving-valuable-constructive-feedback-on-your-code-reviews-457ffb2592f">Giving valuable constructive feedback on your Code Reviews</a> was originally published in <a href="https://medium.com/inside-freenow">FREENOW Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why your hiring process sucks]]></title>
            <link>https://medium.com/@napalmdrivendev/why-your-hiring-process-sucks-21e50512f50d?source=rss-fbb38d625dd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/21e50512f50d</guid>
            <category><![CDATA[recruiting]]></category>
            <dc:creator><![CDATA[Arturo Jiménez]]></dc:creator>
            <pubDate>Tue, 31 Jul 2018 08:43:18 GMT</pubDate>
            <atom:updated>2018-07-31T08:44:12.355Z</atom:updated>
            <content:encoded><![CDATA[<p>I’d like to talk about some things I’ve found during the hiring processes I’ve been involved with. <strong>All processes are not the same</strong>, someone have been really interesting and I’ve dropped (or been dropped) from several. I’m not here proposing any new or revolutionary hiring process flowchart.This said, I’ve checked LinkedIn for five minutes and collected some interesting points I’ve found in the jobs description. I hope this helps to explain my point of view regarding this topic.</p><h3>You have to do this technical assignment before meeting the team or doing any technical interview</h3><p>Because nobody cares about what your opinions on the team are. Nobody cares about what your feelings are regarding your potential new colleagues or if you think you’ll fit there. <em>They are too focused on their problems to really care about a potential employee. It’s kind of the mentality of the king in a castle waiting a new buffoon to entertain him</em>. So, take between 12 to 16 hours of your spare time (this means, take these hours from your family and things that make you happy like hobbies or sports) for coding a really well thought technical assignment. Wait, did I say well thought? sorry, what I actually tried to say is that you’re going to be given the same test you’ve already coded in almost every process you’ve been involved. <strong>Algorithms and coding challenges from GitHub are the usual test of choice.</strong></p><h3>You will be part of the overall RANDOM_COMPANY community of SPECIFIC_TECHNOLOGY developers, sharing best practices, knowledge, and code</h3><p>It’s amazing! every company out there states for the same. This is the point where I actually test the company/team. What happens when you don’t implement your technical assignment the dogmatic way? with that, I mean: <strong>what happens if you KISS (Keep It Simple Stupid) instead of “following” SOLID “by the book”?</strong>. The result usually is the same: <strong>they expect a classic VIPER/Clean Architecture/Hexagonal architecture</strong> seen over and over again in tons of posts and they’re not really open to the change. This pretty much conflicts with the concept of pragmatism.</p><h3>Profound knowledge of SOME FRAMEWORK</h3><p>Because the ability of change is not preferred. <strong>It’s better if you already know everything about the framework and have no idea about what single responsibility means</strong> than having someone that actually cares about the software quality and maintainability and teach them what they need to know about this particular framework.</p><p>This also is a cool spot during the review of your technical assignment. If you know a lot about architecture, they will focus on the framework. If you know a lot about the framework, they will be interested in the architecture.</p><h3>Training, conferences and many opportunities to learn, experiment and grow</h3><p>But… If I have to self-teach myself because the company is not willing to help me with that, and I have to already have a deep understanding of ALL your stack… what are my opportunities to learn exactly?</p><h3>Flexible working hours</h3><p>Are you sure we’re not talking about fake flexible working hours (you join the company and then they tell you you’re going to stay everyday from 9h to 18h) or a huge amount of “core” hours (we have flexible working hours BUT we have to stay here from 9 to 16). 16–9 = 7, if I work 8 hours and I have already 7 hours fixed… where is the flexibility at?</p><h3>A stunning office located in the centre of your town</h3><p>It will provide enough comfort to not have to worry about your fake flexible working hours and it will motivate you to do overtime.</p><h3>Competitive salary and a Permanent contract</h3><p>Until you talk with the recruiters and they try to underpay you. A cool trend right now is telling this amazing story about “Flexible Compensation Plan: Health insurance/ Transport/ Nursery Tickets”. It’s like: I’m not going to pay you what you ask for, but hey, you have this cool things you didn’t ask for and maybe if we sum everything up, the result will be the exact amount you asked for!</p><p>I like to talk about money right at the end of the post because it gives an interesting picture of the whole process: <strong>We want a rockstar, we don’t want to pay for a rockstar.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=21e50512f50d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[This is why you should learn a functional programming language]]></title>
            <link>https://medium.com/@napalmdrivendev/this-is-why-you-should-learn-a-functional-programming-language-1cdd28c2613c?source=rss-fbb38d625dd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/1cdd28c2613c</guid>
            <category><![CDATA[elixir]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[functional-programming]]></category>
            <dc:creator><![CDATA[Arturo Jiménez]]></dc:creator>
            <pubDate>Wed, 25 Jul 2018 07:25:36 GMT</pubDate>
            <atom:updated>2018-07-25T07:29:35.360Z</atom:updated>
            <content:encoded><![CDATA[<p>Functional programming for Android, for iOS, in Kotlin, Swift or Javascript. Lambda expressions, monads, Erlang, Scala. Do these things ring a bell to you? You’ve probably listened or read them before. So, what’s so cool about a paradigm born in the 1950’s with the appearing of this language called <em>Lisp</em>?</p><h3>Functional Programming features</h3><p>Before talking about the benefits of functional programming, I find necessary to mention some features these languages provide us. I would like to explain this features and also charge against the <em>“it’s too complex and it has poor readability”</em> myth by writing examples both in Kotlin and <a href="http://www.napalmdrivendevelopment.xyz/what-is-elixir.html">Elixir</a>. I’m not going to say you’re not going to struggle when learning this but, from my experience, the reason of that is simply because the change of paradigm, not because of any poor readability.</p><p>A <strong>First-class function</strong> is a function that can be stored in variables and data structures, passed as arguments to and returned from other higher-order functions</p><pre>// Kotlin val double = fun(x: Int): Int { return x * 2 } <br># Elixir double = fn(x) -&gt; x * 2 end</pre><p>A <strong>Higher-Order function</strong> is a function that takes functions as parameters, or returns a function.</p><pre>// Kotlin <br>val benchmark = fun(startInMilliseconds: Int): (Int) -&gt; Int { <br> return fun(endInMilliseconds: Int): Int {<br>  return endInMilliseconds - startInMilliseconds <br>  } <br>} </pre><pre>val timeLapse = benchmark(1000) <br>timeLapse(5000) // result: 4000 </pre><pre># Elixir <br>benchmark = fn(start_milliseconds) -&gt; <br> fn(end_milliseconds) -&gt; <br>  end_milliseconds - start_milliseconds <br> end <br>end</pre><p>A <strong>Pure Function</strong> should have the following qualities:</p><ul><li>It should depends only on the input to produce the result, not on any hidden information or external state.</li><li>It shouldn’t cause any observable side effects, like modifying a parameter passed by reference or global variable/object.</li></ul><pre>// Kotlin fun printValue(x: Int) { println(x) } </pre><pre># Elixir def print_value(x), do: IO.inspect(x+1)</pre><p>A <strong>Closure</strong> simply creates a scope that allows the function to access and manipulate the variables outside of its scope. Let’s try to define it again: you can store some data inside a function that’s only accessible to a specific returning function.</p><pre>// Kotlin <br>val benchmark = fun(startInMilliseconds: Int): (Int) -&gt; Int {<br> return fun(endInMilliseconds: Int): Int {<br>  return endInMilliseconds - startInMilliseconds <br> } <br>} </pre><pre>val timeLapse = benchmark(1000)<br>timeLapse(5000) // result: 4000 </pre><pre># Elixir <br>benchmark = fn(start_milliseconds) -&gt;<br> fn(end_milliseconds) -&gt;<br>  end_milliseconds - start_milliseconds<br> end <br>end</pre><p>I will use the same example of High-Order Function again, the variable startInMilliseconds (or start_milliseconds) was enclosed and is only accessible to the returning function.</p><p><strong>Immutable State</strong> means that you can’t change any state at all.</p><pre>// Kotlin <br>val person = Person(&quot;John Doe&quot;) <br>person.name = &quot;Not John Doe&quot; // Fails. Val cannot be reassigned. </pre><pre># Elixir <br>map_set = MapSet.new <br>foo_set = MapSet.put(map_set, &quot;foo&quot;) </pre><pre># map_set = MapSet&lt;[]&gt; <br># foo_set = MapSet&lt;[&quot;foo&quot;]&gt;</pre><h3>Object-oriented Programming VS Functional Programming: fight!</h3><p>High availability, concurrency, parallelism, predictability, distributed systems… have you ever listened this keywords ever? I’m pretty sure it’s the case. Usually, when talking about <strong>Functional Programming VS OOP</strong> we have this tendency to just expose the dark side of Object-oriented Programming. So, let’s try to keep more positive.</p><p>Previously, I’ve enounced a bunch of functional programming features. <strong>Immutable state</strong> may sound like a not particularly interesting feature, but plays a huge role in helping us developing our systems. Not relying on Object Oriented Programming’s mutability concept helps give us <strong>predictability</strong>. Given some input, a function is going to return us the same output whether if it’s running in one core or in a thousand cores. No process is messing around with no state. A lot of <em>complexity is drastically reduced</em> just because we don’t have to worry about keeping threads correctly updated and synchronized.</p><p>Functional programming languages are typically <em>less efficient</em> in their use of CPU and memory than imperative languages. However, such slowdowns are not universal. Programs that perform intensive numerical computations written in a functional programming language <em>has been proven to be only slightly slower than C</em>. Also, <strong>immutability</strong> of data can in many cases lead to <strong>execution efficiency</strong> by allowing the compiler to make assumptions that are unsafe in an imperative language.</p><p>Learning a functional programming language mainly gives you <em>a new perspective</em>. Keep in mind that you can use these functional features explained before in other languages. This said, I would recommend to use a functional language on a future pet project or even apply these concepts to your production code if this is possible.</p><p>This post has been extracted from <a href="http://www.napalmdrivendevelopment.xyz/why-learn-functional-programming.html">my blog</a>.</p><p><em>Originally published at </em><a href="https://gist.github.com/artjimlop/358c65d26ac693cf3bc68ec3f3bb79c4"><em>gist.github.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1cdd28c2613c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>