<?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 gabriel guzman on Medium]]></title>
        <description><![CDATA[Stories by gabriel guzman on Medium]]></description>
        <link>https://medium.com/@gabeguz?source=rss-c959481d38c5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*IH6xI20gAxhBLb6Ekm6JCQ.jpeg</url>
            <title>Stories by gabriel guzman on Medium</title>
            <link>https://medium.com/@gabeguz?source=rss-c959481d38c5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 07:50:28 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@gabeguz/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[Good Practices — Code Review Comments]]></title>
            <link>https://medium.com/@gabeguz/good-practices-code-review-comments-aa530c58f33b?source=rss-c959481d38c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa530c58f33b</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[gabriel guzman]]></dc:creator>
            <pubDate>Tue, 08 May 2018 19:51:01 GMT</pubDate>
            <atom:updated>2018-05-08T19:51:01.368Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*HJXSKyr6g5EAwa_kBRxjIQ.jpeg" /></figure><p>If you do code review, you likely come across the same issues over and over again. People who are contributing to your code base for the first time may not know your team’s internal standards, they may come from a different language and do things slightly differently. A new hire may need to get up to speed quickly on submitting changes to your repository. How can you make sure these cases are handled while minimizing the impact on your code reviewers? One helpful tool is the “Code Review Comments” document.</p><p>A “Code Review Comments” document is a collection of comments that come up again and again in code review sessions. For example, if you’re always having to tell people “Make sure you’re using prepared statements when sending input to an SQL server”, you could just add that to this document, and then when you see unescaped SQL, just point the submitter to your doc.</p><h3>Onboarding New Developers</h3><p>When a new developer joins your team, you can point them to this document so they can get a quick overview of your standard practices. This is a good place to put things like:</p><ol><li>All code must be linted, and conform to our internal code style standards before being submitted for review (you <em>do</em> have code standards right?)</li><li>Code submitted as a PR should be tested by another developer before it’s merged</li><li>We prefer using “guard clauses” rather than deeply nested if / else blocks see: <a href="https://www.thechrisoshow.com/2009/02/16/using-guard-clauses-in-your-ruby-code/">https://www.thechrisoshow.com/2009/02/16/using-guard-clauses-in-your-ruby-code/</a></li></ol><p>Anything that’s not covered by your linter/code formatter can live in this document.</p><h3>Decreasing Cognitive Load</h3><p>Reading code is generally considered harder than writing code so anything that places less cognitive load on the reviewer is good. If all the simple stuff is covered in your Code Review Comments document, then the reviewer can focus on the meat of the change request without having to worry about stuff that they shouldn’t have to worry about. This will also help with personal style differences that may come up in a review. If it’s clearly stated that your team prefers shorter variable names, then it’s harder for someone to argue that in this case, they really think that loopIndexVariable is a better name than i for a loop index because it&#39;s more descriptive.</p><h3>Limiting Bike Shedding</h3><p>If you find yourself constantly getting into arguments over stuff that’s really not that important, you can throw it in the doc (once the team comes to consensus on the best colour to paint the bike shed) and then any time someone thinks another colour would be better, just link them to the doc and be done with it. For more on <a href="https://en.wikipedia.org/wiki/Law_of_triviality">Bike Shedding</a>.</p><h3>Formalizing Team Standards</h3><p>Often, the longer a team works together, the more unwritten rules they will develop for how they like their code. This works great until you try to bring a new person into the group. The new person needs to discover these standards by trial and error, which can be frustrating and take time. Maintaining a Code Review Comments document can help formalize these unspoken standards and reduce friction when a new member joins the team. Instead of having to have several code reviews rejected because of internal standards that everyone else is aware of, the new developer can just read the document.</p><h3>Don’t Over Do It</h3><p>One thing you definitely <em>don’t</em> want to do with this type of document is to fill it with so much minutia that it itself becomes a source of cognitive load for the developer. It should be fairly succinct, and easy to read. A good example of this is the go teams <a href="https://github.com/golang/go/wiki/CodeReviewComments">Code Review Comments</a> document. It’s filled with things that have come up over and over again in code reviews, and have been added to the document to improve the development and code review experience for both the submitter and the reviewer.</p><h3>Starting Your Own</h3><p>It’s really easy to start a document like this. Any time you’re doing a code review and have to comment on the same thing more than once, add it to the document. Get your team to do the same, then you can review the doc together from time to time and decide what to keep and what to discard. When new contributors join the team, send them the doc before they submit their first PR so they can make sure their code is ready for code review.</p><h3>Conclusion</h3><p>Maintaining a Code Review Comments document can be a good way to onboard new developers, decrease the cognitive load on your reviewers, and formalize unwritten team standards. Instead of having to discover these things via trial and error, a new contributor can scan the document and get up to speed with the internal standards of a new team quickly. This can reduce friction for the new developer and improve the code review experience for all parties.</p><p>Do you use a document like this with your team? Feedback, thoughts? Leave a comment.</p><p><em>Originally published at </em><a href="https://dev.to/gabeguz/good-practices---code-review-comments-455"><em>dev.to</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa530c58f33b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What’s DNS?]]></title>
            <link>https://medium.com/@gabeguz/whats-dns-f3a3130ddab8?source=rss-c959481d38c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3a3130ddab8</guid>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[dns]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[computers]]></category>
            <dc:creator><![CDATA[gabriel guzman]]></dc:creator>
            <pubDate>Fri, 27 Apr 2018 00:13:38 GMT</pubDate>
            <atom:updated>2018-04-27T01:09:34.238Z</atom:updated>
            <content:encoded><![CDATA[<p>DNS is basically the address book of the internet. When you type <a href="http://www.duckduckgo.com/">www.duckduckgo.com</a> into your browser, the computer needs to figure out how to get your request to the right server. Routing over the internet works via IP addresses, so to get to <a href="http://www.duckduckgo.com/">www.duckduckgo.com</a>, you first need to figure out what its IP address is.</p><p>This is where DNS, the Domain Name System comes in. At a high level, when you hit enter in your browsers location bar, the browser does a DNS lookup to try and find the IP address of the server name you entered. A DNS lookup consists of calling an Operating System function (a syscall) called gethostbyname(). This function takes a string such as &quot;<a href="http://www.duckduckgo.com/">www.duckduckgo.com</a>&quot; and returns a structure that includes the IP address of the host, among other information. On my system, that struct looks like this<a href="https://dev.to/gabeguz/whats-dns-13c3#fn1">1</a>:</p><pre>struct hostent { char *h_name; /* official name of host */ <br>    char **h_aliases; /* alias list */ <br>    int h_addrtype; /* host address type */ <br>    int h_length; /* length of address */ <br>    char **h_addr_list; /* list of returned addresses */<br>};</pre><p>How does gethostbyname() know what the IP address of <a href="http://www.duckduckgo.com/">www.duckduckgo.com</a> is? Unix like computers (including Macs) have a file called /etc/resolv.conf that tells the Operating System where it should look for name to address lookups, you can check yours by typing cat /etc/resolv.conf in your terminal program.</p><p>Mine looks like this:</p><pre>$ cat /etc/resolv.conf <br># Generated by iwm0 dhclient <br>nameserver 192.168.0.1 <br>lookup file bind</pre><p>That tells me a few things:</p><ol><li>#Generated by iwm0 dhclient This tells me the file itself was generated by the dhclient program. dhclient is the program that hands out IP addresses to computers that request them via DHCP (Dynamic Host Configuration Protocol)</li><li>nameserver 192.168.0.1. This tells me the IP address of a server I can use to lookup names I don&#39;t already know about. This will be important soon.</li><li>lookup file bind This tells the computer what database it should use to &#39;lookup&#39; IP addresses, &#39;file&#39; tells the computer to first check the /etc/hosts file, and &#39;bind&#39; tells the computer to ask DNS for the IP address.</li></ol><p>If you’re a web developer, you’ve likely used the /etc/hosts file to have a web address point to your computer temporarily for testing. If not, that&#39;s ok we&#39;ll talk about it now.</p><p>If you look in /etc/hosts you&#39;ll see something that looks a bit like this:</p><pre>$ cat /etc/hosts <br>127.0.0.1 localhost <br>::1 localhost</pre><p>This is a mapping of IP address, hostname, and aliases. In the above example, there are no aliases defined. If I wanted to prank myself, I could do something like this:</p><pre>$ cat /etc/hosts <br>127.0.0.1 localhost <br>::1 localhost <br>127.0.0.1 <a href="http://www.duckduckgo.com/">www.duckduckgo.com</a></pre><p>Now, when I try to browse to <a href="https://www.duckduckgo.com/">https://www.duckduckgo.com/</a> I get an error, because gethostbyname(&quot;www.duckduckgo.com&quot;) is returning 127.0.0.1, which is the IP address of my local computer, and not the address of <a href="http://www.duckduckgo.com/">www.duckduckgo.com</a>. If I knew the IP address of <a href="http://www.duckduckgo.com/">www.duckduckgo.com</a>, I could put it here and everything would work, at least until the IP of <a href="http://www.duckduckgo.com/">www.duckduckgo.com</a> changed.</p><p>A long, long, time ago, there was no DNS, just a bunch of computers and a bunch of people adding entries to /etc/hosts files by hand, or maybe copy pasting from a file that was distributed by Stanford<a href="https://dev.to/gabeguz/whats-dns-13c3#fn2">2</a>. Eventually this became too cumbersome and someone decided to write some code, thus DNS was born.</p><p>Now we come to the second option in our resolv.conf example, bind. If gethostbyname() can&#39;t find an entry in /etc/hosts it then queries the DNS server specified in the nameserver section of /etc/resolv.conf this is your DNS server.</p><p>So, the Operating System sends a query to 192.168.0.1 asking for the IP address for the “<a href="http://www.duckduckgo.com/">www.duckduckgo.com</a>&quot; server. If 192.168.0.1 knows the IP address, it will return it to you, if not… it will then ask its DNS server (also defined in the /etc/resolv.conf file but now on your DNS server) what the address is for &quot;<a href="http://www.duckduckgo.com./">www.duckduckgo.com.</a>&quot; If <em>that</em> server knows the IP address, it will return it, and if not, it will again ask its DNS server if <em>that</em> server knows the IP address to &quot;<a href="http://www.duckduckgo.com/">www.duckduckgo.com</a>&quot; and so on... until one of two things happens:</p><ol><li>No one knows the IP address of <a href="http://www.duckduckgo.com/">www.duckduckgo.com</a> — In this case you will get an error and someone will have to go fix the DNS records for that website.</li><li>Eventually someone will say “Oh, yeah… I know that guy, here’s his address” — In this case you will then open a TCP request to the IP address that you just found (there’s at least one other full blog post there) and ask the server for a web page.</li></ol><p>That’s basically how DNS works, in a nutshell. But, but but, I hear you ask… how does the DNS server that finally responds know what the IP address is for “<a href="http://www.duckduckgo.com/?">www.duckduckgo.com?</a>&quot; Excellent question. Basically, the administrator or the devops team, or the developer (now that things are all orchestrated and defined in code) will tell the “authoritative” name server for the domain “Hey, I just setup this server, it’s going to host web pages, its name is ‘<a href="http://www.duckduckgo.com/">www.duckduckgo.com</a>&#39; and its IP address is ‘184.72.104.138’.”</p><p>You do this in what’s called a <a href="https://en.wikipedia.org/wiki/Zone_file">Zone file</a>.</p><p>You can play with DNS queries yourself using the dig command:</p><pre>$ dig www.duckduckgo.com <br>; &lt;&lt;&gt;&gt; DiG 9.4.2-P2 &lt;&lt;&gt;&gt; www.duckduckgo.com <br>;; global options: printcmd <br>;; Got answer: <br>;; -&gt;&gt;HEADER&lt;&lt;- opcode: QUERY, status: NOERROR, id: 57389 <br>;; flags: qr rd ra; QUERY: 1, ANSWER: 4, AUTHORITY: 0, ADDITIONAL: 0 <br>;; QUESTION SECTION: <br>;www.duckduckgo.com. IN A <br>;; ANSWER SECTION:<br>www.duckduckgo.com. 123 IN CNAME duckduckgo.com.<br>duckduckgo.com. 59 IN A 23.21.193.169 <br>duckduckgo.com. 59 IN A 107.20.240.232 <br>duckduckgo.com. 59 IN A 184.72.104.138 <br>;; Query time: 51 msec <br>;; SERVER: 8.8.8.8#53(8.8.8.8) <br>;; WHEN: Wed Apr 25 17:41:15 2018 <br>;; MSG SIZE rcvd: 98</pre><p>Most of that stuff you can ignore for now, the interesting thing is the QUESTION SECTION which basically just repeats your query back for you, and the ANSWER SECTION which in this case tells us that &quot;<a href="http://www.duckduckgo.com/">www.duckduckgo.com</a>&quot; is a <a href="https://en.wikipedia.org/wiki/CNAME_record">CNAME</a>(Canonical Name) which is kind of like an alias, to &quot;duckduckgo.com&quot; which has 3 IP addresses: 23.21.193.169, 107.20.240.232, and 184.72.104.138. You should be able to confirm that any of those go to the duckduckgo.com website, by copy-pasting them into your browser (this won&#39;t always work because you can have multiple websites running on the same server at the same IP address).</p><p>That’s all I’ve got to say about that.<br> Questions, feedback? Leave a comment!</p><p><em>Originally published at </em><a href="https://dev.to/gabeguz/whats-dns-13c3"><em>dev.to</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3a3130ddab8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scaling your engineering teams]]></title>
            <link>https://medium.com/@gabeguz/scaling-your-engineering-teams-d807688f2fa4?source=rss-c959481d38c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/d807688f2fa4</guid>
            <category><![CDATA[management-software]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[gabriel guzman]]></dc:creator>
            <pubDate>Tue, 24 Apr 2018 12:33:38 GMT</pubDate>
            <atom:updated>2018-04-24T12:33:38.802Z</atom:updated>
            <content:encoded><![CDATA[<p>I had the pleasure to work with <a href="https://www.linkedin.com/in/cathy-axais-a955b958/back">Cathy Axais</a> when I was a team-lead at Seedbox. She had the unenviable task of being the sole Quality Assurance resource at the company for a team of 30 developers. There was no way she would have been able to keep up with the QA load placed on her if she tried to perform the traditional Dev -&gt; QA -&gt; Production cycle; she needed a way to scale.</p><p>What did she do? She embedded herself with each of the development teams in turn and taught us how to test. What were her requirements? Fairly simple —</p><ol><li>PRs need to be tested before they go to production</li><li>The developer who wrote the code can’t be the developer who tests it</li></ol><p>She spent about 3 weeks with my team, showing us what she looked for when testing a system, how to spot things that were likely to break, and how to get into the “testing mindset.” This wasn’t the easiest thing to do, sometimes we (developers) can be grumpy when presented with change, but from my point of view it paid off in spades. After she finished with us, she went to the next team, and so on until she’d gotten all the developers on board. I don’t have the numbers, but I know the defect rate dropped substantially once we stopped testing our own code, an optimization that I take for granted now, but hadn’t really considered before.</p><p>I haven’t found a better way to scale a supporting function to the development process. Need your application to be secure? Don’t pass it over to a security team, instead get the security team to teach the developers what to look for to spot insecure code, and show them how to fix it. Want performance? Don’t call in a bunch of performance experts to fix all your performance problems, call in one, and get her to instil the “performance mindset” in your developers.</p><p>This is what full-stack means to me. You get subject matter experts who can help your teams improve the functions they might not be optimized for. Every hand off of the code before it reaches production increases the time it takes to get features out the door, especially if there is a path that returns that code to the developer where the process has to start again. How many of us have worked in environments where getting code to production requires QA sign-off, security review, architecture review, a release manager, a release date, a roll-back plan, and 4 hours of your day (if everything goes well)?</p><p>Each of those steps presents the possibility that your code might go all the way back to the starting line, possibly days after you last touched it.</p><p>If you want to move fast, it’s important to keep your feedback cycles as short as possible. Often that means getting developers to do <em>everything</em>. Ops, security, performance, QA, deployment, site reliability. None of these things should be outside of the ability of the team.</p><p>I’m not saying you should get rid or your QA team, or your security team, or your SREs, just that you should think of them as subject-matter experts who can educate your developers on best-practices for their area of expertise. Think of them more as mentors, and tool builders. For example, Ops can build out infrastructure as code so that the development teams can define their own infrastructure needs independent of the ops team. We’ll always need the ops team for when we hit the limits of our understanding, or for architecture planning assistance, but we should be able to come to them with 80% of the work already done.</p><p>Passing your code off to another group leads to bottlenecks, and there will always be defects that get through. I think it’s better to find the defects quickly and push fixes just as quickly. Get the feedback cycle as short as possible and educate your developers in areas where they are weak.</p><p>How do you scale your teams?</p><p><em>Originally published at </em><a href="https://dev.to/gabeguz/scaling-your-engineering-teams-2b9e"><em>dev.to</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d807688f2fa4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[$DREAM_JOB]]></title>
            <link>https://medium.com/@gabeguz/dream-job-e21c5d9fbd33?source=rss-c959481d38c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/e21c5d9fbd33</guid>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[culture]]></category>
            <category><![CDATA[careers]]></category>
            <dc:creator><![CDATA[gabriel guzman]]></dc:creator>
            <pubDate>Wed, 04 Apr 2018 20:30:27 GMT</pubDate>
            <atom:updated>2018-04-04T20:30:27.010Z</atom:updated>
            <content:encoded><![CDATA[<p>Everyone has some idea of what their ideal job would look like. Unlimited vacation, respect, a company car, power over your destiny, meaningful work, etc. Most of us probably don’t currently work at our dream job and so we hop around looking for a better deal. I try to mold my current job into the job I want it to be.</p><p>What are some examples of what I mean? Several companies ago I was working somewhere that didn’t have an automated deploy process, and regularly ssh’d to production to make changes. In my mind, the ideal workplace would have some kind of automated process to get changes into production, so I set one up. No one asked me to do it, I just felt it was important and did it.</p><p>Another example, from a different employer, when I arrived there was no code review practice in place. I talked to the team and suggested we should try requiring at least one other person’s approval before allowing a change set into the master branch. There was some arguing at first, but we decided to try it for a sprint. In the end we decided to keep doing it and I felt like I’d made a change for the good.</p><p>On a non technical note, the first team lead I ever had said something to me that I’ve tried to carry over everywhere I’ve worked: “I always have time for my team, even if I look super busy, please interrupt me.” This is an attitude change that costs almost nothing to implement and has an outsized impact on your team. Just letting them know that you’re there for them helps set a positive tone.</p><p>What are you looking for? Is it more autonomy? Is it more impact? Is it a company car? If you can’t list the things that you’re looking for, you won’t be able to make changes towards those things.</p><p>How do you get there? Ask yourself “What can I do right now to move $CURRENT_JOB towards $DREAM_JOB?” And then, look at the outcome of that. Did your action have any impact?</p><p>If yes, congratulations, you are now one small step closer to having your $DREAM_JOB. Lather, rinse and repeat.</p><p>If not, all is not lost, but this could be a sign that your current employer is not open to change. Try again, and see what happens. I take the view that we can all be agents of change regardless of where we sit on the org chart. There are things I can do on a daily basis that will impact those around me. Some simple examples:</p><p>- being helpful <br>- being positive<br>- empathizing with others<br>- implementing process changes<br>- automating tedious tasks</p><p>This may not work in all situations. You need to gauge the impact your changes are having. Are people responding? Is the climate such that your changes can work for the good? Sometimes you come to a roadblock. Sometimes you get a clear message that what you’re trying to do is not supported by your employer. Eventually, you have to ask yourself a harder question: “Is it worth pushing for change here, or should I try to find somewhere that’s more open to change?” In my opinion, as long as your changes are working and you’re happy with your compensation, then keep pushing to make things better.</p><p>And of course, if your $DREAM_JOB *does* come along, well… take it.</p><p>Originally posted at <a href="https://dev.to/gabeguz/dreamjob-3o4">https://dev.to/gabeguz/dreamjob-3o4</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e21c5d9fbd33" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>