<?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[Efe&#39;s Essays - Medium]]></title>
        <description><![CDATA[Essays on distributed systems and software engineering by Efe Karakus - Medium]]></description>
        <link>https://medium.com/efekarakus?source=rss----da2af0c4b8c7---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Efe&amp;#39;s Essays - Medium</title>
            <link>https://medium.com/efekarakus?source=rss----da2af0c4b8c7---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 04:10:45 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/efekarakus" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Domain knowledge vs. Technical skill]]></title>
            <link>https://medium.com/efekarakus/domain-knowledge-vs-technical-skill-15a2f14783d8?source=rss----da2af0c4b8c7---4</link>
            <guid isPermaLink="false">https://medium.com/p/15a2f14783d8</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[personal-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[careers]]></category>
            <dc:creator><![CDATA[Efe Karakus]]></dc:creator>
            <pubDate>Tue, 12 Jun 2018 19:25:43 GMT</pubDate>
            <atom:updated>2018-06-12T19:25:43.060Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>“Most talented developers do not have much interest in learning about the specific domain in which they are working, much less making a major commitment to expand their domain-modeling skills. Technical people enjoy quantifiable problems that exercise their technical skills. Domain work is messy and demands a lot of complicated new knowledge that doesn’t seem to add to a computer scientist’s capabilities.”</blockquote><p>The above quote is from the <a href="https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215/ref=sr_1_2?ie=UTF8&amp;qid=1528690573&amp;sr=8-2&amp;keywords=domain+driven+design&amp;dpID=51sZW87slRL&amp;preST=_SX218_BO1,204,203,200_QL40_&amp;dpSrc=srch">Domain-Driven Design book by Eric Evans</a> and captures a struggle that many of my friends and I face. We want to find work that’s pretty much a continuation of our computer science degrees. We admire senior engineers that worked on complex systems. So when I ask myself “how can we be like them?”, my first thought is that I lack their technical skill set.</p><p>I believe we jump to that conclusion because we see their blogs or videos of interesting problems for a finished product with the correct success criteria. We don’t get to see their explorations, previous failures, lessons learned along the way. It seems to me that you can only push the boundaries like them once you become a pro in your field. And you become a pro by being a domain expert.</p><p>Even with my short work experience, I can tell that understanding your business domain and building the right thing tends to be the hardest part of a product vis-à-vis the underlying technical problems.</p><p>If you only work on a technically interesting problem without understanding its impact, how do you even judge if you’re actually successful? Can we say that the technical skills that we acquired amount to anything if there are no end results to prove it? So I don’t think that doing technical tasks without understanding the surrounding context is a transferable skill.</p><p>Is domain specific knowledge transferable then? It’s hard to say. There seem to be many products that fail although their leaders were previously successful. At Amazon, we have the <em>Are Right, A lot</em> <a href="https://www.amazon.jobs/en/principles">leadership principle</a> <em>. </em>I would still prefer to follow the judgement of an engineer that has a track record of success versus someone that might be just technically savvy.</p><p>In summary, are domain-modeling skills worth investing into? It seems to me that by mastering a domain, you’ll end up with a technically challenging problem because nobody else would have explored those waters anyway.<br>On the other hand, if you are handed down a technical problem without an understanding of why, I find it hard to believe that you’ll get any purpose from it and know in which scenarios to apply those skills.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=15a2f14783d8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/efekarakus/domain-knowledge-vs-technical-skill-15a2f14783d8">Domain knowledge vs. Technical skill</a> was originally published in <a href="https://medium.com/efekarakus">Efe&#39;s Essays</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Client-side row versioning in DynamoDB]]></title>
            <link>https://medium.com/efekarakus/client-side-row-versioning-in-dynamodb-fecd9f3d2f39?source=rss----da2af0c4b8c7---4</link>
            <guid isPermaLink="false">https://medium.com/p/fecd9f3d2f39</guid>
            <category><![CDATA[versioning]]></category>
            <category><![CDATA[dynamodb]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[nosql]]></category>
            <dc:creator><![CDATA[Efe Karakus]]></dc:creator>
            <pubDate>Mon, 26 Mar 2018 04:21:37 GMT</pubDate>
            <atom:updated>2018-03-26T04:21:37.150Z</atom:updated>
            <content:encoded><![CDATA[<p>Say your application needs to maintain the history of its records. There are multiple ways of achieving this with <a href="https://aws.amazon.com/dynamodb/">DynamoDB.</a> See <a href="https://stackoverflow.com/a/24275045/1201381">https://stackoverflow.com/a/24275045/1201381</a> as an example solution.</p><p>Your architecture should be built around your application’s use-cases. The layout below can be used if you don’t expect your users to access older versions frequently.</p><p>We can maintain two separate tables for the resources that need versioning.</p><h4><strong>Resource Table</strong></h4><p>The <em>resource</em> table contains only the latest version for each item. The <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey">primary key</a> of the table is just its partition key. In the table below, the primary and partition key is just a <em>hash </em>which is a String. The version is a Number. The remaining attributes define your resource. Since <em>hash</em> is the only attribute for the primary key, any new entry with the same <em>hash</em> will overwrite the row.</p><p>We assume that any operation that updates a record, a new update, or a rollback should <strong>always increment the version</strong> number of the item.</p><pre>          +----------+---------+-------------------+<br>          |   hash   | version |   attr1..attrN    |<br>          +----------+---------+-------------------+<br>          | 1c5815b2 |    2    |  some values      |<br>          +----------+---------+-------------------+</pre><h4><strong>Resource History Table</strong></h4><p>The <em>resource-history</em> table contains every revision of the items. It will have more storage, but can have a lower read capacity if you do not expect the users to retrieve older entries frequently. The main difference is that the primary key is a composite key (<em>partitionKey: hash, sortKey: version</em>), so every new <em>version</em> for the same <em>hash</em> will have its own row.</p><pre>          +----------+---------+-------------------+<br>          |   hash   | version |   attr1..attrN    |<br>          +----------+---------+-------------------+<br>          | 1c5815b2 |    2    |  some values      |<br>          +----------+---------+-------------------+<br>          | 1c5815b2 |    1    |  some old values  |<br>          +----------+---------+-------------------+</pre><h4>CREATE</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/465/1*Kw9KxfxLvSaJw1jngj-3lA.jpeg" /></figure><p>Creating a new item involves first writing the item to the <em>resource-history </em>table, and then writing the same entry to the <em>resource</em> table.<br>If the first step fails, then nothing has been written to the tables and the user can safely issue another request.<br>If the second step fails, then there will be an extra record that’s in the <em>resource-history </em>table. You can think of this scenario as a DELETE for the previous <em>hash.</em></p><h4>READ</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/464/1*BFTW8XFUgcyWVHeCO27a3A.jpeg" /></figure><p>Retrieving the latest item requires us just to fetch the record with that <em>hash</em> from the <em>resource</em> table. We are guaranteed to have either one or no record for a given <em>hash.</em></p><h4>UPDATE</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/485/1*lI8-bfm2LdaSb4Iu2uWSSQ.jpeg" /></figure><p>Updating an existing item requires us to first fetch the item’s latest version from the <em>resource </em>table, increment its version, and then write the new entry to both tables just like in CREATE.<br>The failure scenarios are similar to the CREATE operation. If the new entry is added only to the <em>resource-history </em>table, then when the user requests the same update operation, the previously created entry with the key (<em>hash, v2</em>) in <em>resource-history</em> will be replaced.</p><h4>DELETE</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/465/1*-Riwk8OD9MuVmlw5xsev2Q.jpeg" /></figure><p>Deleting an item requires us to only delete it from the main <em>resource</em> table.</p><h4>Alternatives</h4><p>If you work with a single table and try to have immutable records, then the UPDATE operation is going to have a user experience trade-off.<br> <br>For example, if you decide to implement the <a href="https://stackoverflow.com/a/24275045/1201381">stackoverflow</a> answer listed in the introduction, you will have two writes to the same table. Depending on the order you’ve chosen, if the second write operation fails, then the user will either see their item deleted or you’ll lose a historical record.</p><p>Client side row versioning is not perfect. Our solution also has drawbacks as explained above, but the customer experience is better than actually losing data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fecd9f3d2f39" width="1" height="1" alt=""><hr><p><a href="https://medium.com/efekarakus/client-side-row-versioning-in-dynamodb-fecd9f3d2f39">Client-side row versioning in DynamoDB</a> was originally published in <a href="https://medium.com/efekarakus">Efe&#39;s Essays</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[(User) Stories]]></title>
            <link>https://medium.com/efekarakus/user-stories-7183f5814ec8?source=rss----da2af0c4b8c7---4</link>
            <guid isPermaLink="false">https://medium.com/p/7183f5814ec8</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[user-stories]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Efe Karakus]]></dc:creator>
            <pubDate>Tue, 06 Feb 2018 01:35:27 GMT</pubDate>
            <atom:updated>2018-02-06T01:35:26.871Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>The process becomes the proxy for the result you want. You stop looking at outcomes and just make sure you’re doing the process right. Gulp.<br>- Jeff Bezos. <a href="https://www.amazon.com/p/feature/z6o9g6sysxur57t">2016 Letter to Shareholders</a>. Resist Proxies.</blockquote><p>We all know of software engineering teams advertising themselves with some sort of <a href="http://agilemanifesto.org/principles.html">Agile</a> framework. Yet, too many teams follow a process just because it is supposed to be agile. We don’t stop and think deeply about what each step is supposed to achieve. If the step does not bring value to the customer, we should remove it from our process.</p><p>Writing user stories is one of these steps that engineers are expected to do as part of the routine. Why? Because writing good stories gives early visibility to stakeholders and team members on what you are working on. This visibility before implementation is valuable information as it validates that your work matches expectation and you are tackling stories in the correct priority.</p><p>Unfortunately, from experience, stories tend to be written in a rainbow of different formats by every teammate. In workshops, we learn that they should be written as: <br>As a &lt;who&gt;, I want to &lt;what&gt; so that &lt;why&gt; <br>Not too many engineers enjoy this template because it means you don’t get to code right away. You can’t just write “Add drop-down menu to header” and jump into coding. You have to pause and think about what you are building. Finding and convincing yourself that the task has any value tends to be hard. As engineers <a href="https://www.youtube.com/watch?v=4E3xfR6IBII">we should strive to gain mastery of a domain</a>. Because without becoming a true expert at a field, we won’t be pushing its boundaries.</p><p>I always struggled applying that template to anything that’s not a customer facing feature. For example, how do you follow this template for an operational task such as adding logs or alarms? <em>&lt;Wh</em>o&gt; do you write it for? Isn’t the <em>&lt;what&gt; </em>too specific for a stakeholder? However, we can not deliver the feature without these tasks with high standards. I could skip the template, but then I miss on the thought-process behind making the change.</p><p>So, I found myself writing two types of stories: <em>feature stories</em> and <em>engineering stories</em>.</p><p><em>Feature stories</em> are the user stories that you write from the point of view of your customer. The audience is your stakeholders. So the acceptance criteria also have to be from their point of view. Acceptance tests should capture the different interactions and expected outcome the customer has with your feature. There can be several code commits attached to a <em>feature story</em>. Finally, it’s perfectly okay to change the story definition as we have more conversations with our stakeholders.</p><p>Here is an example feature story for a Twitter user that wants to follow more than one account recommendation at once:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*39jbIx-fCsMCrHKd7lbA_w.png" /><figcaption>Example feature story</figcaption></figure><p>Note that that story is kept small on purpose. We have not included more refined acceptance criteria such as combining all success notifications into one. Its scope is very limited. It’s better to put a small working version in front of the customer as soon as possible, then we can stir the feature roadmap based on feedback.</p><p><em>Engineering stories</em> are strictly under <em>feature stories. </em>They are written from the point of view of the engineers that own the feature. They map to a single code commit. I find myself more productive if all my changes are captured and progress is shown on the story board. <br>Since the audience of these stories are my teammates, I sometimes discard the <em>who</em> but elaborate more on <em>why </em>and <em>how</em>. This allows me to get earlier feedback on the technical solution. This is captured under the description section and a potential solution is described under the programming model section<em>. </em>The acceptance criteria becomes unit tests and integration tests. If I judge that the story is fairly straight forward, I don’t include a programming model or acceptance criteria.</p><p>Here is an example engineering story under the feature defined above:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lMbLJTr8Uxk-s-H2EpDHPA.png" /><figcaption>Example engineering story</figcaption></figure><p>The templates themselves are not as important as the goal of the stories, which is to promote visibility and validationf. I like having two different formats depending on the audience reading them. Our whole team should follow the same templates so that the stakeholders know how to validate the stories.<br>Finally, we should always re-evaluate our process and adjust our methods as we go.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7183f5814ec8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/efekarakus/user-stories-7183f5814ec8">(User) Stories</a> was originally published in <a href="https://medium.com/efekarakus">Efe&#39;s Essays</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>