<?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 A.A. Grapsas on Medium]]></title>
        <description><![CDATA[Stories by A.A. Grapsas on Medium]]></description>
        <link>https://medium.com/@andrewgrapsas?source=rss-6780a18f2f28------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*tEIKX03YaQp20s3G-GRN3w.jpeg</url>
            <title>Stories by A.A. Grapsas on Medium</title>
            <link>https://medium.com/@andrewgrapsas?source=rss-6780a18f2f28------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 14:32:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@andrewgrapsas/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[Getting Hired: Hugo Engineering Part 1]]></title>
            <link>https://medium.com/@andrewgrapsas/getting-hired-hugo-engineering-part-1-330bdc080e62?source=rss-6780a18f2f28------2</link>
            <guid isPermaLink="false">https://medium.com/p/330bdc080e62</guid>
            <category><![CDATA[lessons-learned]]></category>
            <category><![CDATA[hiring]]></category>
            <category><![CDATA[recruiting]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[startup]]></category>
            <dc:creator><![CDATA[A.A. Grapsas]]></dc:creator>
            <pubDate>Mon, 26 Feb 2018 15:33:58 GMT</pubDate>
            <atom:updated>2018-03-01T18:06:11.411Z</atom:updated>
            <content:encoded><![CDATA[<p>Want to know how to get hired at Hugo?</p><p>In this two part series I will explore my experiences as a candidate in the interview process across two industries (games and FinTech), discuss some of the general concepts we used to build our interview system, and then get into the nitty-gritty (in part 2) of what our process looks like and what makes a great candidate.</p><p>I have linked the <em>games</em> and <em>financial technology</em> segments separately so you can read at your leisure.</p><h3><a href="https://medium.com/@andrewgrapsas/getting-hired-games-industry-5c30b1f61487">Games Interviews</a></h3><p>Hugo is not a games company; but, having spent about half of my career in games, I cannot discuss hiring without first mentioning the source of my entry into the world of software engineering. Just as importantly, I want all of our candidates to understand the universe I am coming from: the special forces of software engineering.</p><h3><a href="https://medium.com/@andrewgrapsas/getting-hired-financial-engineering-3db4f214b908">Financial Technology Interviews</a></h3><p>Hugo <em>is</em> related to the financial technology industry. Some call us InsureTech; but, at the end of the day, we’re here to build whatever best serves the needs of our community — insurance or otherwise. As such, I think of us as a financial technology company. The root of our common needs with the FinTech market can be summarized as: we can never go down. Ever. Our products need to always be on, always be available, and always be serving our communities.</p><h3>Hugo’s Process</h3><p>When founding Hugo with <a href="https://www.linkedin.com/in/davidbergendahl/">David</a>, we spent countless hours discussing what we wanted the interviewing experience to be like at Hugo. We knew we could not make our process as long and involved as larger, more established companies. A startup operates under different constraints than a large, established company. Here are some core considerations:</p><h4>1. Interview Fatigue</h4><p>Interviewing is exhausting for both the candidate and the interviewer. The larger a company, the greater the buffer that exists to allow recovery time for employees that have been involved with the interview process (at every company I have been at, we have accounted for the hours of recovery required when interviewing candidates).</p><p>At a small company, the “human mass” is minimal and, as such, the overall impact an interview has on the schedule, employees, and company as a whole is far greater.</p><h4>2. Interview Experience</h4><p>There are two sides to the interview experience: the candidate’s and the interviewers’. In both cases, regardless of the outcome, the interview should “feel good”. Larger/prestigious companies may get away with grueling interview schedules, re-scheduled meetings, and general indifference/rudeness. We can’t get away with that (and even if we could, we wouldn’t want to). Instead, we need to minimize every ounce of friction and create something mutually-beneficial, as <em>this is the company building its reputation from the ground up, interview by interview, this is the definition of what the company will become, and this is an extension of how the company values employees</em>.</p><h4>3. Mutual Identification</h4><p>At the end of the day, the process, questions, and discussions must identify whether the candidate matches the company and whether the company matches the candidate. This second facet, the idea that a company might not match the candidate’s needs, expectations, life experience, or some other factor is a constant conversation David and I have.</p><p>We want all of our employees choosing us for the right reasons, all cards on the table, all questions answered. After all, we are here to make the world a better place, and that starts with our work environment, carries itself throughout the code we write, and ends up delivered to our communities and customers.</p><h4>Hugo in Summary</h4><ul><li>Emphasis on good use of everyone’s time</li><li>Minimize fatigue on both sides</li><li>Make sure “good fit” applies to all parties</li><li>Transparency of process (more on this another time)</li></ul><p>In the near future, I will write more specifically about our process when interviewing engineers, including exactly what we are looking for in our hires.</p><p>Want to know more? Feel free to reach out to me.</p><p>And, as always:</p><p>We’re hiring! <a href="http://work.withhugo.com/">Come work with us</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=330bdc080e62" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Hired: Financial Technology]]></title>
            <link>https://medium.com/@andrewgrapsas/getting-hired-financial-engineering-3db4f214b908?source=rss-6780a18f2f28------2</link>
            <guid isPermaLink="false">https://medium.com/p/3db4f214b908</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[lessons-learned]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[fintech]]></category>
            <dc:creator><![CDATA[A.A. Grapsas]]></dc:creator>
            <pubDate>Mon, 26 Feb 2018 15:25:39 GMT</pubDate>
            <atom:updated>2018-03-01T18:08:55.376Z</atom:updated>
            <content:encoded><![CDATA[<p>Every company and every industry is going to be different. I can only speak to my particular experiences. The financial technology space operates under very specific constraints that are somewhat similar to <a href="https://medium.com/@andrewgrapsas/getting-hired-games-industry-5c30b1f61487">games</a>, especially in terms of building reliable systems; but, there are a unique set of constraints that exist for financial technology engineers.</p><p><a href="https://www.theguardian.com/business/2015/apr/17/uk-halts-bond-sale-bloomberg-terminals-crash-worldwide">Imagine a government not being able to issue a bond because your software is down</a>.</p><p>I have spent a lot less time in FinTech than in video games; but, when I was in FinTech I worked for a true giant in the field. Admittedly, my particular role required both a breadth of knowledge and a good deal of depth (sound familiar? Yup, just like a games engineer) <em>and </em>an ability to teach large groups of engineers the same topics; so, my personal interview experience was definitely colored by those requirements. Luckily, I was also responsible for interviewing other candidates across the company. As such, I feel pretty comfortable “generalizing” the experience and process.</p><h3>The Interview</h3><p>Interviewing in FinTech (unsurprisingly) involves the usual HR phone call, two or more phone screenings (usually focused on specifics of a language the candidate indicates they know well), possibly a small code test or challenge (this is usually executed online and involves multiple choice questions or small code problems), and then involves an on-site with multiple engineers. Topics will relate to operating systems (I/O, IPC, concurrency, memory layout, etc.), data structures, algorithms, language specifics (usually C++ and Java, but this will heavily depend on the position), and there will usually be a small amount of topical problem solving in there (topics the candidate is expected to know based on their history, resume, etc.).</p><p>The company I was at spent a great deal of effort and training making the interview process as good an experience for the candidate as possible — this stuck with me. As a giant of the tech world, the company could have turned the interview into a meat grinder (similar to games); instead, they wanted to make sure every single candidate felt great at the end.</p><p>What I found interesting about the FinTech world is that the interviews felt tailored to what I had already indicated I knew and what I was applying for, rather than a blanket application. As a candidate, I greatly appreciated this experience. Instead of trying to solve some <a href="https://www.inc.com/business-insider/google-hardest-interview-questions.html">Google-esque</a> problem, every question was concrete, meaningful to my future job, and asked by an expert level individual in the topic (my C++ conversations were with core maintainers of a high performance C++ library, my Java questions by individuals teachings and writing books on high performance Java, etc.).</p><h3>FinTech in Summary</h3><ul><li>Companies want engineers of all experience levels</li><li>As a whole, there is a willingness to mentor, grow, and educate</li><li>Long term focus on personal growth goals</li><li>Interviews are reality- and practicality- focused with a greater emphasis on “do you know what you say you know”</li><li>A lot of focus on making the candidate have a good experience</li><li>Product needs to work all the time regardless of outside or internal factors</li></ul><p>Want to know more? Feel free to reach out to me.</p><p>And, as always:</p><p>We’re hiring! <a href="http://work.withhugo.com/">Come work with us</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3db4f214b908" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Hired: Games]]></title>
            <link>https://medium.com/@andrewgrapsas/getting-hired-games-industry-5c30b1f61487?source=rss-6780a18f2f28------2</link>
            <guid isPermaLink="false">https://medium.com/p/5c30b1f61487</guid>
            <category><![CDATA[lessons-learned]]></category>
            <category><![CDATA[games]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[A.A. Grapsas]]></dc:creator>
            <pubDate>Mon, 26 Feb 2018 15:23:06 GMT</pubDate>
            <atom:updated>2018-03-01T18:11:48.062Z</atom:updated>
            <content:encoded><![CDATA[<p>Every year for several years I sat on a panel of alumni that spoke to prospective computer science students. Inevitably, when it came time to ask questions, the vast majority were aimed at my career (at the time): video games.</p><p>Hopefuls would want to know about how to get into the industry, what they needed to study, and what prospects were like. I always started with the same simple explanation: “You probably won’t break into games,” I would say, parents staring death rays through me. “There are few openings and many applicants. There are almost never junior level opportunities. Game engineers are like the special forces of software engineering, they have to be simultaneously versatile and specialized, you need to deeply understand the mission, your role, and how to execute in an intense environment. You need to sacrifice.”</p><p>“Worse,” I would add, “games companies want you to already have games experience. But, you cannot get that experience without being in the games industry. Basically, hiring in games operates under a catch-22. You only break that rule when you are the best. The brightest. When you can already makes games without having necessarily done so professionally.”</p><h3>The Interview</h3><p>Interviews for game companies are notoriously challenging. This is especially true of the <a href="https://en.wikipedia.org/wiki/AAA_%28video_game_industry%29">triple-A</a> space, where games are required to operate in strict compute and memory budgets with extremely tight schedules. The risks are great with triple-A, and the only way to mitigate the risks is to have a very talented, well-honed team that specializes in the nuances of that scale and style of development.</p><p>Games interviews usually begin with the traditional HR phone screening, are followed by one or more technical phone screenings (where the candidate must solve mathematical and algorithmic problems on-the-fly), have a “take home test” component (either a code challenge or series of code problems, usually in C++ with a focus on well-formed code that performs), and then resolve to the on-site interview.</p><p>Many on-site interviews begin with a written test that will be shared with each interviewer (again, this test will involve analyzing and writing C++ on the fly and solving math problems). After the test, the candidate meets with individual or groups of interviewers that cover mathematics, algorithms, data structures, problem solving, software design, and requirements engineering (at the minimum).</p><p>At the end of the day, even if a candidate does really well in their interview, they may not be given an offer. A better candidate may have interviewed, or a specific strength that the team needs may not be present in the candidate (for example, specialized understanding of tools engineering). So, even if a candidate is a great engineer <em>and</em> has a background in games engineering <em>and </em>does well on the interview, they might not receive an offer.</p><h3>Games in Summary</h3><ul><li>Companies need and want Valve style <a href="https://www.linkedin.com/pulse/what-your-t-shape-unique-approach-employee-jamie-christensen/">T-shaped people</a></li><li>The industry avoids hiring juniors and, even when hired, there rarely is any level of in-house training</li><li>Studios focus on their current and immediate needs (often rejecting candidates because they do not fit into the current shape, issues, etc. of the company or office or team at present)</li><li>Interviews are grueling, not necessarily topic specific, and meant to simulate the stress of “a day in the life”</li><li>Products need speed of development, extreme performance, to work within tight constraints, and to be reliable</li></ul><p>Want to know more? Feel free to reach out to me.</p><p>And, as always:</p><p>We’re hiring! <a href="http://work.withhugo.com/">Come work with us</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5c30b1f61487" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hugo Tech Stack]]></title>
            <link>https://medium.com/@andrewgrapsas/the-hugo-tech-stack-db130c8e460?source=rss-6780a18f2f28------2</link>
            <guid isPermaLink="false">https://medium.com/p/db130c8e460</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[lessons-learned]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[tech]]></category>
            <dc:creator><![CDATA[A.A. Grapsas]]></dc:creator>
            <pubDate>Wed, 21 Feb 2018 21:38:10 GMT</pubDate>
            <atom:updated>2018-02-22T00:48:49.671Z</atom:updated>
            <content:encoded><![CDATA[<p>At Hugo, our tech stack emphasizes simplicity, transparency, and ease of use above all else.</p><p>First, it is important to understand that a strict adherence to specific technologies is not a sustainable method of building a great company. At the same time, an offhandedness to technical choices is extremely destructive, especially to early stage companies (imagine trying to grok the end-to-end of a product using 6+ languages — I have been there).</p><p>At Hugo, we will always be evaluating, evolving, and improving our stack of technologies and technical solutions; but, for the moment, we maintain a fairly clear vision of what tools will help us achieve the best outcomes for our community and facilitate the best engineering experience for our employees.</p><p>I divided each major technical component into its own post for thoroughness. In some instances, topics that are related have still been broken up to allow a more thorough exploration of our reasoning around the choices we have made.</p><h3>Our Stack and Technologies (in-depth)</h3><ul><li><strong>Language:</strong> <a href="https://medium.com/@andrewgrapsas/the-hugo-tech-stack-language-2c193dbdf799">JavaScript</a></li><li><strong>Framework(s):</strong> <a href="https://medium.com/@andrewgrapsas/the-hugo-tech-stack-node-express-9c6ef9af5548">Node &amp; Express</a></li><li><strong>State:</strong> <a href="https://medium.com/@andrewgrapsas/the-hugo-tech-stack-couchbase-429f384709a7">Couchbase</a></li></ul><h3>Other Technologies</h3><p>We use many other technologies at Hugo and I will dedicate future posts to fleshing out our diligence process and considerations around the various frameworks, technologies, and applications we deploy. Here are a few to mention:</p><h4>DigitalOcean</h4><p>Our primary cloud provider is DigitalOcean. We initially chose DigitalOcean because we started as a company of one engineer (myself) and DigitalOcean has done an amazing job of creating a simple, intuitive experience with well written guides. Additionally, DigitalOcean is extremely responsive to needs, issues, and tickets, a vital requirement for an early stage startup.</p><p>In the future, we will be moving our infrastructure across multiple cloud providers to guarantee no single point of failure can affect our users.</p><h4>Docker/DockerSwarm</h4><p>All of our micro-services, infrastructure services, database instances, etc. run within containers. <a href="https://www.linkedin.com/in/david-hiebert-0231a918/">Dave</a> (our amazing developer operations engineer) could probably write a book on what we have learned since moving to this configuration; but, I will summarize the primary outcomes:</p><ul><li>High availability (load balancing across many automatically managed instances)</li><li>Security (many layers of walls separating any single intrusion vector)</li><li>Ease of deployment (rolling deployments)</li><li>No single point of failure</li></ul><h4>Kafka</h4><p>Kafka is a technology that Dave and I have had prior experience with. At Hugo, we use Kafka to capture events that are handled by our stream processing infrastructure to perform what I will term “incidental” interactions (such as messaging a user when they have left their car insurance on for too long).</p><h4>Jenkins</h4><p>We continuously deploy software. As such, we needed a secure means of continuous integration to both guarantee quality of deployment AND execute our deployments. Additionally, we use Jenkins for scheduled jobs.</p><h4>Git/GitHub/ZenHub</h4><p>Git has been a core requirement for software engineering for what feels like a very long time. At Hugo, we have a very specific workflow to guarantee that bugs, tasks, and features are all being executed at a high level of quality without negatively affecting our employees. Expect a future blog post about process at Hugo and how we balance work, life, and the needs of our community.</p><h4>ELK</h4><p>The ElasticSearch/LogStash/Kibana stack has proven itself time and time again. At Hugo, we love ELK. ELK enables us to quickly sift through the large volumes of information our micro-services constantly report and identify issues, bugs, and bottlenecks quickly and with specificity.</p><h3>Conclusion</h3><p>At Hugo, we use a lot of different technologies to achieve our goal of serving our community by building the best car insurance out there.</p><p>This list is, for obvious reasons, not exhaustive. We use many libraries, frameworks, operating systems, and technologies to create a high availability product with as high a quality of work/life balance as can be achieved.</p><p>Want to know more? Feel free to reach out to me.</p><p>And, as always:</p><p>We’re hiring! <a href="http://work.withhugo.com/">Come work with u</a>s.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db130c8e460" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hugo Tech Stack: Couchbase]]></title>
            <link>https://medium.com/@andrewgrapsas/the-hugo-tech-stack-couchbase-429f384709a7?source=rss-6780a18f2f28------2</link>
            <guid isPermaLink="false">https://medium.com/p/429f384709a7</guid>
            <category><![CDATA[lessons-learned]]></category>
            <category><![CDATA[couchbase]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[startup]]></category>
            <dc:creator><![CDATA[A.A. Grapsas]]></dc:creator>
            <pubDate>Wed, 21 Feb 2018 21:25:35 GMT</pubDate>
            <atom:updated>2018-02-22T01:07:33.084Z</atom:updated>
            <content:encoded><![CDATA[<p>At Hugo, we <strong><em>love</em></strong><em> </em>Couchbase.</p><p>Database choice is critical to being able to create high availability systems, move quickly, and ultimately to keeping the ship running. As a rule of thumb, databases tend to fall into one of two categories: 1) super cool cutting edge technology or 2) tried, true, beat up, and old.</p><p>In many ways, the past few years have seen a convergence as databases that were once cool have become battle proven. Others (that shall not be named) have persisted (no pun intended), maintaining their cool status and never really achieving the status of tried and true.</p><h3>What is Couch…Base?</h3><p>Couchbase is a surprisingly less-advertised, cool, cutting edge, beat up, battle worn, amazing database technology that has diligently added features and abilities over time to reach across the wide breadth of needs found in the database world. As the name <em>clearly</em> implies, Couchbase is a mash up of <a href="http://couchdb.apache.org/">CouchDB</a> and <a href="http://memcached.org/">Memcached</a> (Well, Membase, which was a mash up of Memcached with a simple db layer). But, do not confuse Couchbase as a simple mashup. It is much, much more.</p><p>First off, Couchbase is a <a href="https://en.wikipedia.org/wiki/Document-oriented_database">document store</a> engineered for containing JSON documents. Couchbase effortlessly clusters, distributes, redistributes, and keeps your data from vanishing (unlike the shall-not-be-named-alternative… sounds like Mongoose).</p><p>Couchbase works straight out of the box with minimal configuration. Given the need, one can configure Couchbase for increased performance, reliability, and to handle very specific forms of load with minimal effort. Couchbase even handles cross-data-center communication easily.</p><p>Finally, Couchbase has a query language engineered from the ground up for querying across JSON documents (<a href="https://www.couchbase.com/products/n1ql">N1QL</a>).</p><h3>Major Deciding Factors</h3><ol><li><strong>Schema-less</strong>— Early in a product’s development, it is <em>impossible</em> to know what form data will take. Every moment spent writing SQL statements to update a schema, debug issues with a schema, writing migration scripts, etc. is another moment not spent building features that will get you live or critically help your community and users.</li><li><strong>Effortless distribution </strong>— Without a running database, there is no product. As such, we needed a database that could easily run with many instances without any intervention on our part. Couchbase is built from the ground up to run in a cluster (and even run across data centers, I can’t emphasize how critical of a feature that is for FinTech!).</li><li><strong>Many, many years of past experience</strong> — At the end of the day, I had extensive personal experience using Couchbase in production serving millions of monthly active users. I was fortunate enough to hire <a href="https://www.linkedin.com/in/david-hiebert-0231a918/">Dave</a>, a brilliant developer operations engineer, whom I have worked with in the past and also has an extensive history of deploying production Couchbase clusters to serve millions of users. Experience let us know that Couchbase would solve our needs and do so in a way that would continuously serve our community of users.</li><li><strong>N1QL</strong> — The addition of a query language to Couchbase means that we can use our cluster for more than simple key-value storage (basically fast read/write of simple documents). This enables us to create far more robust, interesting experiences and removed the need for additional data storage solutions for insights, complex analysis, etc.</li></ol><h3>Conclusion</h3><p>We <strong><em>love</em></strong> Couchbase.</p><p>Couchbase solves our problems, fits our needs, and has an amazing ability to grow with us as our userbase increases, load changes, data centers move, and business needs change. I can honestly say there is not a single other database I would rather be using or that comes even close to the love affair I have with Couchbase.</p><p>You can <a href="https://medium.com/@andrewgrapsas/the-hugo-tech-stack-db130c8e460">find more about the rest of our tech stack here</a>.</p><p>Want to know more? Feel free to reach out to me.</p><p>And, as always:</p><p>We’re hiring! <a href="http://work.withhugo.com/">Come work with u</a>s.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=429f384709a7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hugo Tech Stack: Node & Express]]></title>
            <link>https://medium.com/@andrewgrapsas/the-hugo-tech-stack-node-express-9c6ef9af5548?source=rss-6780a18f2f28------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c6ef9af5548</guid>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[expressjs]]></category>
            <category><![CDATA[node]]></category>
            <dc:creator><![CDATA[A.A. Grapsas]]></dc:creator>
            <pubDate>Wed, 21 Feb 2018 20:59:12 GMT</pubDate>
            <atom:updated>2018-02-22T00:57:05.423Z</atom:updated>
            <content:encoded><![CDATA[<p>Node is the backend framework of choice for us at Hugo with Express used for generating HTTP services.</p><p>Why did I separate Node from our conversation around why we chose <a href="https://medium.com/@andrewgrapsas/the-hugo-tech-stack-language-2c193dbdf799">JavaScript</a>? I felt that the specifics of Node vs. other backend technologies (even when discussing languages) needs its very own consideration.</p><h3>Node</h3><p>Node is inherently simple, as it fundamentally employs an arguably “simple” language (JavaScript). There are properties of JavaScript that make Node a reliable, flexible solution (some of which are highlighted below) and there are additional aspects to Node that just make it a great framework. We decided upon Node partially because it has:</p><ol><li><strong>Event-based execution within a single thread </strong>— Engineers are bad at multi-threading (even very experienced ones). The asynchronous nature of JavaScript means that the language (and Node) handle IO-bound operations without interfering with execution and do it without the engineer ever having to think twice about race conditions, exclusion, signals, or any other construct required by other languages and frameworks.</li><li><strong>Support for performance </strong>—<strong> </strong>We have yet to need it, but the plugin support for Node (whether writing C++ or <a href="https://blog.risingstack.com/node-js-native-modules-with-rust/">Rust</a>) means that segments of code that are slow upon proper analysis (meaning we monitor performance, identify bottlenecks, and then optimize as appropriate) can be rewritten incidentally in a “faster” language. I do not see this as a practice that we will commonly employ; but, there is a good feeling knowing (especially as an ex-games developer) that we can eek out even more performance from our micro-services and libraries <em>if a need is identified</em>.</li><li><strong>Support for all backend activities</strong>— Writing a full HTTP service in Node is fairly straightforward (once you have decided what technology to use). Additionally, writing a tiny, transparent, and easy-to-understand script with Node is equally easy. This means that we can use JavaScript for writing our micro-services AND for scripts that might need to be occasionally or habitually executed. This creates a single competency that can be shared across the team. Other languages <em>could</em> be used for writing scripts, but tend to have cumbersome concepts (like static typing) that make scripts balloon and hide intent within a small amount of business-specific lines of code.</li></ol><h3>Express</h3><p>I wanted to include Express as part of our stack and in relation to Node. Why Express? It just works. Express is fast enough, easy enough to use, and achieves the requirements of a production HTTP service.</p><p>More importantly, our micro-services all share a common micro-service library that adapts Express, meaning that we can change to any other technology without having to mutate a single line of code in our micro-services themselves.</p><p>So, we are less advocates of Express (over other Node libraries that solve the same problems), and more following a fairly pervasive industry standard with an eye to tomorrow.</p><h3>Good Abstractions</h3><p>If you were to look at any of our micro-services, you would hardly recognize some of our technical decisions. We follow the law of not repeating ourselves. As such, we abhor boilerplate code.</p><p>You can <a href="https://blog.withhugo.com/micro-services-shared-architecture-11d624c28bf7">read more about the specifics here</a>, where we discuss reusable frameworks for micro-services.</p><h3>Conclusion</h3><p>We are really happy with our choice of Node. The framework is fast (we will post performance metrics another time), easy to develop with, allows both simple scripts and complex micro-services, and has a good set of features that will help us future-proof our technology decision.</p><p>You can <a href="https://medium.com/@andrewgrapsas/the-hugo-tech-stack-db130c8e460">find more about the rest of our tech stack here</a>.</p><p>Want to know more? Feel free to reach out to me.</p><p>And, as always:</p><p>We’re hiring! <a href="http://work.withhugo.com/">Come work with u</a>s.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c6ef9af5548" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hugo Tech Stack: Language]]></title>
            <link>https://medium.com/@andrewgrapsas/the-hugo-tech-stack-language-2c193dbdf799?source=rss-6780a18f2f28------2</link>
            <guid isPermaLink="false">https://medium.com/p/2c193dbdf799</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[node]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[decision-making]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[A.A. Grapsas]]></dc:creator>
            <pubDate>Wed, 21 Feb 2018 20:40:47 GMT</pubDate>
            <atom:updated>2018-02-22T00:57:16.959Z</atom:updated>
            <content:encoded><![CDATA[<p>We use JavaScript at Hugo as our primary language. That means that we use JavaScript on the backend, JavaScript for command line scripts, and JavaScript for all of our frontend coding. When and if we build mobile applications, we will definitely start with JavaScript (and then evaluate from there).</p><p>Our goal is to build an expert level core competency in JavaScript across every engineering hire we make and, just as importantly, we are not afraid to teach, dialog, and evolve.</p><h3>Proactively Choosing a Language</h3><p>Often times, languages are chosen more for convenience than strategic reasons. All too often, I have found myself using a language because it was what the code base founders knew, what the industry recommended, or what was easy to hire for.</p><p>The three facets of Hugo engineering decisions (simplicity, transparency, and ease of use) were used when weighing our options. I have been fortunate enough to write production code in a wide array of languages (C, C++, C#, Java, ActionScript, JavaScript, etc.) and, more importantly, have always been a heavy contributor in every code base I have worked in (meaning that I end up having a wide taste of the language, its capacity and nuances, etc.). Just as importantly, I have taught several programming languages both at the university level and for a private FinTech company.</p><h3>Why JavaScript</h3><p>When it came time to choose a core language for Hugo, I decided on JavaScript for a few reason:</p><ol><li><strong>The language gets out of your way</strong> — Fundamentally, JavaScript is a “simple” language (very few types, very little syntax, follows C-family conventions), meaning that the code is easy to read, mutate, and maintain.</li><li><strong>Wide community support </strong>— As the language of the web, JavaScript is ubiquitous, with an ever growing mass of libraries published across distribution networks. Just as importantly, JavaScript has been around for a long time and there are no signs that it is going away anytime soon (a critical aspect when making a decision that will heavily impact overall infrastructure).</li><li><strong>Easy to test</strong> — Creating and injecting mocks, spies, stubs, etc. in JavaScript is very straightforward and apparent and there are many mature testing frameworks (and linters, static analyzers, etc.).</li><li><strong>Ever improving </strong>— The JavaScript ecosystem evolves at a rapid clip, gaining new libraries, new engine versions, and generally constantly becoming a better, faster language with more sophisticated capabilities. This is a huge advantage for a company making a deep bet like a core programming language.</li><li><strong>Full stack</strong> — Finally, JavaScript can be executed across the <em>entire</em> stack. JavaScript is, arguably, the most versatile language in existence, as it can effortlessly (yes, effortlessly) run within micro-services, scripts, in the browser, on mobile, and on embedded systems (see: <a href="https://www.espruino.com/">Esprino</a>). This means less training, it means engineers have more capacity to work across the entire stack, and it means learnings apply to every line of code written at the company.</li></ol><p>Why not a language that degrades to JavaScript? The track record for languages that eventually transpile to JavaScript is filled with dead or dying projects. At the end of the day, we know JavaScript is here to stay.</p><h3>Conclusion</h3><p>At Hugo, we might not always write JavaScript. There is no way to predict the future and, as with all of our tech choices, this is an ongoing discussion open to new opinions, data points, and needs. But, we feel that it is a pretty safe bet that JavaScript will be around for a good, long time and will enjoy a place in our core competency for equally long.</p><p>JavaScript might not be the right language for you (depending on your needs); but, when it comes to building inherently complex systems (like on-demand car insurance) with a small, dedicated, and highly skilled team, we felt that JavaScript was the best solution.</p><p>You can <a href="https://medium.com/@andrewgrapsas/the-hugo-tech-stack-db130c8e460">find more about the rest of our tech stack here</a>.</p><p>Want to know more? Feel free to reach out to me.</p><p>And, as always:</p><p>We’re hiring! <a href="http://work.withhugo.com/">Come work with u</a>s.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2c193dbdf799" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Being a CTO: Eating the Elephant]]></title>
            <link>https://medium.com/@andrewgrapsas/being-a-cto-eating-the-elephant-e0d554db729d?source=rss-6780a18f2f28------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0d554db729d</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[startup-lessons]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[A.A. Grapsas]]></dc:creator>
            <pubDate>Mon, 19 Feb 2018 20:22:52 GMT</pubDate>
            <atom:updated>2018-02-19T21:23:22.155Z</atom:updated>
            <content:encoded><![CDATA[<p>The hardest part of being the CTO of an early-ish phase startup is eating the elephant. Every. Single. Day.</p><blockquote>Q: How do you eat an elephant?</blockquote><blockquote>A: One bite at a time.</blockquote><p>I have been a full time CTO &amp; co-founder for what <a href="https://www.linkedin.com/in/agrapsas/">LinkedIn</a> calls 9 months. In that time, we have deployed a <em>lot</em> of production software and infrastructure (containers, micro-services, custom authentication, analytics, logging, metrics, backup policies and strategies, recovery, a mass of business logic, event-based systems, custom frontend code, long term encrypted storage, continuous integration, code standards and analysis, etc., etc., etc.) and, amazingly, even taken on our first users for the beginning of our soft launch.</p><p>This amounts to many tens of thousands of lines of unit tested, linted, statically analyzed code across dozens of repositories.</p><p>Most of this engineering has involved a very, very, very tiny team, even by the standards of an early stage (seed) startup. A “handful” would be nice. Instead, we have 1 full time full stack engineer (myself), 1 full time developer operations engineer (the Amazing <a href="https://www.linkedin.com/in/david-hiebert-0231a918/">Dave</a> without whom my crazy engineering goals would never be achieved) and three contract engineers primarily working on front-end activities (meaning the backend, administrative tooling, reusable libraries and infrastructure, scripts, etc. are all left squarely in my bucket).</p><p>I have eaten a lot of elephant. So has my co-founder, <a href="https://www.linkedin.com/in/davidbergendahl/">David</a>, though not of the technology kind. His is a flavor of business, communications, and product that must taste confusing to the palette.</p><p>So, how can you take a startup from 0 to 60 in such a short time and still write highly available, highly reliable products that incur as minimal debt as possible? I have a few words of wisdom that I live by:</p><h3>Build standards early</h3><p>Go ahead and write up that engineering handbook before you have another engineer writing code. Codify how your code <em>must</em> (not should) look and explain your reasoning. Be prepared to adapt your handbook.</p><p>Do not fear breaking your code base apart early. Go ahead, it’s OK to begin abstracting code you use repeatedly into libraries, having several repositories, etc. early on.</p><h3>Change fast</h3><p>Once you have separated your code base into reusable chunks and adapted external dependencies, do not be afraid of change. I have rewritten “core” libraries a few times now due to changing business concerns, evolving infrastructure, and new discoveries. You have to. Otherwise, you end up with technical debt that reduces the pace and productivity of your tiny team.</p><p>In the early stage, you have less “live” dependencies, so, changes have less impact.</p><h3>Test everything</h3><p>Automated testing means changes to libraries and dependencies are less painful. You can prove a change does not introduce new, unexpected behavior by having unit tests.</p><p>We use JavaScript as our main backend language at Hugo because I would rather 10 lines of transparent logic and hundreds of lines of unit tests than the general level of obfuscation that occurs in more verbose languages (Java, C#, Scala, etc.).</p><h3>Communicate</h3><p>I have an amazing co-founder and an outstanding team; but, that does not mean I can operate in a void and just remain isolated on my current task. Instead, communication must be constant and methodical. We use GitHub/ZenHub for state and state changes, Hangouts for standups and face-to-face conversations, and Slack for everything in-between.</p><p>I constantly talk to my co-founder about my technical decisions, especially as they impact our roadmap and development cycles. But, specifically, I talk through <em>why</em> I am going back to rewrite a library or spending time abstracting a layer. This is critical, as it allows us to plan, execute, and, honestly, in such a small team you <em>need</em> to talk through changes to make sure you have accounted for all business dependencies.</p><p>More importantly, everyone on the team (whether early stage or later stage) needs to understand the product, the problem in question, and how each task serves end users. Without this clarity, it is impossible to weigh immediate technical needs against the strict requirements of feature development and impossible to ensure that the “obvious” solution is, in fact, the best one.</p><h3>Avoid burnout</h3><p>This is not a sprint. We are building high availability, reliable systems that people depend upon. At the end of the day, everything needs to work. Period. Full stop. No exceptions.</p><p>I will write more about how we avoid burnout at Hugo another time; but, for now, know that being flexible in where and how you work, admitting when you have bitten off more than you can chew, and having good communication around delivery and delivery requirements all help to achieve a sustainable pace (what we call a cycle at Hugo).</p><p>Burnout leads to sloppy code, poor decision making, and constantly chasing the most immediate fire (it is really hard to reflect and predicatively adapt your code when your gas tank is constantly running on empty).</p><p>Just as importantly, burnout seeps into every part of an individual’s life. We take family and personal life very seriously at Hugo (David and I founded the company while starting our young families, so this has been a deep consideration from day one for us).</p><p>For all of these reasons, crunch and the inherent burnout that results is just not acceptable.</p><h3>There’s always another elephant</h3><p>Last but not least, in the software world there is always another elephant; so, make sure each and every bite is bringing you closer to not just devouring your current elephant, but sharpening your tools for the next. We take cycle retrospectives, 1-on-1 check-in’s, and our “thinking out loud” Slack channel seriously to make sure everyone is thinking not just about how to do the next task on the heap, but how to do it better.</p><p>I hope you found this useful, even if only as a reminder that we are all working through our own massive task lists.</p><p>Drop me a line if you have any questions.</p><p>And, as always:</p><p>We’re hiring! <a href="http://work.withhugo.com/">Come work with u</a>s.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0d554db729d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Goldilocks Problem of Unit Tests]]></title>
            <link>https://medium.com/@andrewgrapsas/the-goldilocks-problem-of-unit-tests-39f7b3334de?source=rss-6780a18f2f28------2</link>
            <guid isPermaLink="false">https://medium.com/p/39f7b3334de</guid>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[startup-lessons]]></category>
            <dc:creator><![CDATA[A.A. Grapsas]]></dc:creator>
            <pubDate>Fri, 15 Dec 2017 04:10:09 GMT</pubDate>
            <atom:updated>2017-12-15T04:17:14.142Z</atom:updated>
            <content:encoded><![CDATA[<p>Unit tests are like sweaters, they need to fit your needs perfectly or they will rapidly be discarded.</p><p>When I was in video games, we laughed at the idea of writing unit tests. Unit tests, in our minds, were for products that never shipped, or that had countless developers toiling away, barely comparable to the immense productivity game engineers achieved.</p><p>We, on the other hand, needed to get out the door yesterday.</p><p>Later in my career, I encountered the concept of writing tests <em>after</em> building features. I won’t name names or places; but, several Java enterprise developers I knew gave lip service to tests, and would happily add tests to their code to indicate that “yes, we have tests” — yet, the purpose, meaning, and reason for tests escaped them (and me, at the time).</p><p>It was not until I entered the FinTech (financial technology) world and observed large scale engineering of high availability, distributed systems with massive foundational libraries and immense effort that I was truly educated on the what, why, and how of properly testing.</p><h3>Test What You Need</h3><p>The first rule of unit tests that I learned was that there is no single solution for how many or what depth of unit tests you, as a developer, should write around your features.</p><p>There are some general rules, however, and I think they are universally applicable. Beyond these rules, the problem being solved and the constraints of your operation will influence you exact rigor of testing and modality.</p><p>For me, the general rules of testing are as follows:</p><ol><li>Write tests with your code</li><li>Write tests from the “bottom up”</li><li>Test (at the very minimum, and sometimes at the maximum) the interface being developed</li><li>Write failure cases before success cases</li><li>Failed tests mean code cannot move</li><li>Fix the test, do not delete it</li></ol><h4>Tests with code</h4><p>Writing tests <em>after </em>your code induces one of two conditions: 1) you will need to change your code to match the new expectations of your interface that evolve as you discover the actual use of your methods or 2) you will hack together your tests around hard-to-test code.</p><p>(Aside: if your code is hard to test, you probably did a poor job of abstracting your code and have strong dependencies and poor cohesion — more on this in a separate post).</p><p>Additionally, writing your tests as you write your code furthers your understanding of how end-users of your component will interact with the provided interface. This allows you to build a better designed interface, as you will be forced to think through encapsulation, initialization, and guarantees around expected and unexpected behavior.</p><h4>Bottoms up!</h4><p>To reduce complexity, begin testing at the smallest unit (the component furthest at the bottom of the dependency chain — meaning that the component has near-zero dependencies). This will facilitate good practices at the simplest (least interactions) unit that will influence more dependency-heavy components.</p><p>Working the other way often guarantees you will have to change code, as dependency heavy code will inevitably require mocks, spies, etc. that will need to reflect behaviors of more independent components.</p><p>Often times, when you work through problems from a bottom up approach, you will do a better job of breaking apart strong dependencies. When building top down, it is very easy to fall into the problem of having god objects (components with far too many responsibilities, often disparate in nature).</p><h4>Interfaces and brittleness</h4><p>You must test the interface. That is, take whatever contract you expose to your component’s users (for example, guarantees about rejections of promises, exceptions, or return codes, or requirements for the specific state of data that, if violated, will cause unexpected behavior) and supply tests to assert this behavior.</p><p>This provides all the benefits we expect when unit testing: prevention of regressions, affirmation of functionality, documentation of use, etc.</p><p>When discussing unit tests, we must discuss both <em>code coverage</em> (the percentage of lines of code executed during a component’s tests) and <em>brittleness</em> (the idea that tests that are built to internal — not interface — expectations will inevitably break as code is refactored and adapted).</p><p>In general, brittleness in a test is considered a bad trait, as it can often lead to teams ignoring failing tests (do not ignore failing tests!) and often results in developers hating unit tests.</p><p>However, the <em>depth</em> of testing you do will be dependent on the constraints of your engineering requirements. For example, a financial product (or insurance product) will require 100% code coverage. This means that every single path in the code MUST be executed (and ideally with every possible permutation of data and state). As such, there is no way to not have a subset of your unit tests that are brittle (more on brittle tests and how to make them as efficient and maintainable as possible in another post — just know that they are required in high reliability codebases).</p><h4>Fail first</h4><p>When writing unit tests, write failure cases first. This allows you to build out more “reliable” code and cultivates consideration of what is and is not expected by both the user of the interface and the interface itself.</p><p>Additionally, I find that writing failure cases quickly identifies bugs and edge cases in your code, as it forces you to think through all the possible unusual behavior a user can invoke upon your component.</p><p>It is too tantalizing to write the success case right away. Fight the urge. Blow up your code a few times before moving to the easier to achieve success case.</p><p>In financial engineering, we often talk about writing unit tests as if they were proof by induction. Solve the 0 case, then the 1 case, the n case, and the n + 1 case (did I get that right? It’s been a long time since discrete math). But, more importantly, really focus on all the egregious acts that can be performed upon your interface (missing data, incorrectly formatted data, partial data, etc.).</p><h4>Do not advance broken code</h4><p>If a test fails, it means your code is broken. Fix it. Use good tools and practices to prevent failing tests from allowing code to move between environments (for example, from a local branch to any environment-based branch like dev or stable).</p><h4>Fix it!</h4><p>When a test fails, fix it. Do not delete tests unless they no longer apply (for example, if an interface changes). In general, it’s good practice to look at the percentage of code coverage between pull requests, merges, or however you are managing the introduction of new code into your codebase.</p><p>Each new addition should maintain or improve the coverage of unit tests.</p><h3>Discipline</h3><p>Writing unit tests is all about discipline and fit. If your users can stand to live without your product for a time (and magically will return after a failure), then maybe you do not have to be as militant about every line of code. However, if you are in a place of providing a life-altering service (such as car insurance, healthcare, financial services, etc.) or are on-the-line for loss of revenue, then there is a good chance that you need to be always available, always correct.</p><p>Any time I have not written tests, any time I have broken my own rules, I have regretted the act.</p><p>But, live and learn and build better code.</p><p>Hopefully I will get to share more specifics and examples in the near future. We here at<a href="http://withhugo.com/"> Hugo Insurance</a> have a custom unit test framework for Node that we are hoping to open source in early 2018; so, stay tuned for that — we think we have a worthwhile addition to the universe of JavaScript testing.</p><p>And, as always:</p><p>We’re hiring! <a href="http://work.withhugo.com/">Come work with u</a>s.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=39f7b3334de" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Micro-services: shared architecture]]></title>
            <link>https://medium.com/@andrewgrapsas/micro-services-shared-architecture-11d624c28bf7?source=rss-6780a18f2f28------2</link>
            <guid isPermaLink="false">https://medium.com/p/11d624c28bf7</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[startup-lessons]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[A.A. Grapsas]]></dc:creator>
            <pubDate>Sun, 10 Dec 2017 22:35:36 GMT</pubDate>
            <atom:updated>2017-12-11T15:09:33.235Z</atom:updated>
            <content:encoded><![CDATA[<p>How do you share code across independent micro-service codebases?</p><p>While not necessarily the most in-depth question to ask when establishing conventions and standards for micro-services at your company, this is a fundamental physical question that needs to be answered before you really can begin pressing out new micro-services.</p><p>Where will your code live? How will it be separated between “reusable” units? What is required in order to configure a new micro-service? Is there any boilerplate?</p><p>At <a href="http://withhugo.com/">Hugo Insurance</a>, the goal of our micro-service architecture is not just to gain the benefits of infrastructural micro-services, but to also reduce the quantity of non-business-purpose code required to exist in a codebase in order for that codebase to fulfill its product-level goals.</p><p>In other words: we want to minimize boilerplate, configuration, and setup code and really isolate the code associated with a micro-service’s individual purpose. There are a few reasons for this:</p><ol><li><strong>Easy change tolerance across codebases</strong> — As each micro-service only manages dependencies specific to its business functions, general libraries and codework that are managed by micro-service libraries can be updated, bug fixed, and addressed without micro-service authors needing to intervene (for example, if we wanted to change from <em>Express</em> to another competing library, we could republish our core libraries without any micro-service owner needing to make a change, as we now have a nice level of abstraction above the dependency)</li></ol><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a4b9c376d12913bbbc63b57105e93f74/href">https://medium.com/media/a4b9c376d12913bbbc63b57105e93f74/href</a></iframe><p>2. <strong>Code intent is clearer</strong> — Having less code means that the “intention” of the code in the repository is clear and specific, we do not have to try and figure out how some set of boilerplate included libraries are used, their configuration, etc. Instead, any new developers or existing maintainers only need worry about the specialized business logic represented in the code.</p><p>3. <strong>Easier to test </strong>— With the micro-service code abstracted, business-logic becomes easier to test. In our case, we have a standard set of mocks that are distributed with the core micro-service library, allowing very, very easy unit testing and preventing duplication of effort.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cab4081772df315ce8a5d02d7ef41e31/href">https://medium.com/media/cab4081772df315ce8a5d02d7ef41e31/href</a></iframe><p>Beyond setup, we have tried to simplify the code around expected interactions and create more “semantic” code (code that is more apparent in meaning based on the language used).</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9d7dfeb9c561d2dedacc34ecf5159b29/href">https://medium.com/media/9d7dfeb9c561d2dedacc34ecf5159b29/href</a></iframe><h3>Division of Code</h3><p>It is important to break your codebases into reusable libraries. Each library contains several components that have shown value and are topical to the library.</p><p>At the moment, our libraries are divided out like this:</p><ol><li><em>poplab-core — </em>This is where we store reusable Node components, ones that are independent of project or product. This includes string, array, and object utilities, encryption/decryption, uuid generation, etc. Basically, the components needed for any real Node project.</li><li><em>poplab-hugo</em> — This library is rapidly reaching the point where it will need some separation; but, in essence the <em>hugo</em> library contains reusable business logic specific to the <em>hugo</em> product (car insurance) that needs to span micro-services. For example, this library contains data access objects (DAO’s) for users, descriptions of models stored in the database, bindings between data and parseable keywords (particular to messaging in our application), etc.</li><li><em>poplab-core-service</em> — The star of this particular blog series, this contains our custom wrapper around Express, connections to our databases, cross-micro-service configuration, authentication, and basically any code that is “common” across any micro-service we plan on launching (this is important for infrastructure, as well, as we know all of our micro-services have specific HTTP endpoints that can be used for health checks, version checks, etc.).</li></ol><p>(What is <em>PopLab</em>? PopLab is the technology company building the Hugo Insurance product! Another post will discuss the challenges of sharing code across an organization and products).</p><p>In terms of publication, we target specific Git tags in our repositories. This allows us to rapidly roll out critical bug fixes for specific versions (updating all outstanding tags) and add new features or API breaks without necessarily affecting all running micro-services simultaneously.</p><p>Our goal in the future is to be able to publish specific tagged versions of our micro-services, as well; but, for now, we simply have branches that reflect different levels of stability in the specific micro-service (master, dev, staging, production, etc.).</p><h3>Aside: Architecture vs. Infrastructure</h3><p>As a side bit, I have been mentioning micro-service architecture and micro-service infrastructure. For me, the architecture of a micro-service involves the shared software living around the services. The infrastructure is the operational code and technologies that allow services to live, scale, deploy, etc.</p><p>This distinction is important, as we generally are discussing two different classifications of developers: operations and engineering. Operations involves management of assets (machines, virtual machines, etc.), installs (OS, kernels, 3rd party software, etc.), deployments (how does a service get on a box, in a container, etc.) and engineering involves the product-focused solutions (business logic) and software around that (maintaining code libraries, etc.)</p><p>The lines may get a little blurry here or there, especially at a small company, when talking about roles; but, there is a physical separation if you look at it from the perspective of: are you delivering code or are you delivering the meta around code.</p><p>I hope you found this useful for thinking about how you’ll achieve your micro-service architecture. I am pretty proud of what we have achieved; but, of course, we are constantly learning, evolving, and adapting.</p><p>Drop me a line if you have any questions.</p><p>And, as always:</p><p>We’re hiring! <a href="http://work.withhugo.com/">Come work with u</a>s.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11d624c28bf7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>