<?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 Rully Afrizal on Medium]]></title>
        <description><![CDATA[Stories by Rully Afrizal on Medium]]></description>
        <link>https://medium.com/@rullyafrzl?source=rss-e490a8bef557------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Yak772VUzuHZAPgx5lZgvQ.jpeg</url>
            <title>Stories by Rully Afrizal on Medium</title>
            <link>https://medium.com/@rullyafrzl?source=rss-e490a8bef557------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 21:55:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rullyafrzl/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[When the Applause Stopped in Tech]]></title>
            <link>https://rullyafrzl.medium.com/refactor-when-the-applause-stopped-in-tech-02fc93e6c878?source=rss-e490a8bef557------2</link>
            <guid isPermaLink="false">https://medium.com/p/02fc93e6c878</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[philosophy]]></category>
            <dc:creator><![CDATA[Rully Afrizal]]></dc:creator>
            <pubDate>Wed, 06 Aug 2025 16:31:08 GMT</pubDate>
            <atom:updated>2025-08-22T15:02:03.442Z</atom:updated>
            <content:encoded><![CDATA[<p>When the Applause Stopped in Tech</p><p>Between 2020 and 2022, I thought I was going to have one of the most important jobs in the world.</p><p>The world was in chaos, but tech? Tech was thriving. Lockdowns pushed everything online, VC money poured in, and companies were desperate for engineers. Remote work became the norm. Salaries jumped overnight. Startups were hiring like crazy, vacancies were abundant, and it felt like every week a new unicorn was born.</p><p>I was in college around those good old days. While my classmates were worrying about grades and final projects, I was hopping between internships at unicorns and startups. It was the golden age of tech.</p><p>Even though I was “just an intern,” I felt like I was already in the big leagues. I wasn’t just learning how to code, I was helping build products that “changed the future”, “used by many” (or so we were told). Friends would say, “Wow, you’re working at that startup? You’re set for life!” And I believed it. The hype of the industry fed my pride. I started thinking of myself not just as a student, but as part of a special, untouchable class of people building the digital world.</p><p>We were the golden children of the pandemic economy. And I felt untouchable.</p><h3>Then the music stopped.</h3><p>Layoffs started hitting headlines, first a few, then thousands. Unicorns that once felt unstoppable began tightening budgets and froze hiring. The vibe shifted from “move fast and break things” to “move cautiously and survive.”</p><p>It was a shock.</p><p>And here’s the hard truth: <strong>when the hype disappeared, so did a lot of my drive.</strong> Without the industry constantly telling me I was important, I started to wonder if I had ever been valuable, or if I was just lucky to be in the right place at the right time. My burnout didn’t come from staying up all night for overtime. <strong>It came from losing the sense of purpose I had during those exciting years</strong>.</p><p>Looking back now, I understand that those boom years were not “normal.” They were just a one-time event caused by a rare moment in history. But when you’re living in it, it’s easy to believe that level of success and excitement will last forever. When things go back to normal, it feels like you’ve fallen from the top.</p><p>The truth is, the work itself never lost its value. Tech still powers the modern world. It still needs creativity, skill, and persistence. The only difference is that now, the spotlight is gone, and that’s okay.</p><p>Maybe the lesson is to keep feeling proud of what you build, even when no one is cheering.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=02fc93e6c878" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bump Version Automation Pipeline]]></title>
            <link>https://rullyafrzl.medium.com/bump-version-automation-pipeline-2edff03b4e73?source=rss-e490a8bef557------2</link>
            <guid isPermaLink="false">https://medium.com/p/2edff03b4e73</guid>
            <category><![CDATA[gitlab]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[semantic-versioning]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[Rully Afrizal]]></dc:creator>
            <pubDate>Sat, 18 May 2024 12:43:25 GMT</pubDate>
            <atom:updated>2024-05-19T02:35:06.498Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*dQPUirXtfvr04QbASi4wyA.png" /></figure><p>Sebagai seorang software engineer yang memiliki waktu terbatas, waktu yang sudah tersita oleh countless meetings, presentations, coding, dan lain sebagainya. Sebaiknya memang sudah jadi keharusan kita untuk <strong>invest in automation</strong>, dimulai dengan mendelegasikan repeated small tasks ke dalam sebuah proses yang bisa berjalan tanpa campur tangan kita di dalamnya.</p><p>Mengotomasi proses bump version adalah salah satu langkah awal yang tepat. Proses ini sering kali memakan waktu dan prone to human-error. Sudah banyak tools seperti GitHub Actions, Gitlab CI/CD, Jenkins, atau CircleCI yang dapat membantu kita membuat pipeline yang berjalan secara otomatis.</p><h3>Semantic Versioning</h3><p>Semantic Versioning adalah sebuah skema, atau sebuah aturan yang memiliki tujuan untuk memberi tanda adanya perubahan di sebuah perangkat lunak dengan cara yang jelas dan mudah dipahami. Dalam semantic versioning, terdapat 3 bagian yang dipisahkan dengan titik</p><blockquote>{major}.{minor}.{patch}</blockquote><ol><li><strong>Major</strong> adalah angka yang harus ditingkatkan jika terjadi perubahan besar dalam software yang kita buat. Misalnya perubahan arsitektur, business logic, ataupun API yang ada di dalam perangkat lunak.</li><li><strong>Minor</strong> adalah angka yang harus ditingkatkan ketika terjadi perubahan kecil yang tetap kompatible degan versi sebelumnya. Perubahan yang terjadi pada versi minor ini tidak mengganggu fungsi-fungsi lain yang sudah ada.</li><li><strong>Patch</strong> adalah angka yang harus ditingkatkan ketika terjadi perbaikan bug atau perubahan yang lebih kecil dari versi minor. Perubahan ini teteap kompatibel dengan versi sebelumnya dan tidak mengganggu fungsi lain yang sudah ada.</li></ol><p>Contoh:</p><ul><li><strong>v1.0.0</strong>: Versi pertama yang stabil</li><li><strong>v1.1.0</strong>: Terjadi penambahan fitur yang kompatibel dengan versi major 1</li><li><strong>v1.1.1</strong>: Perbaikan bug terhadap versi 1.1.0</li><li><strong>v2.0.0</strong>: Perubahan besar yang tidak kompatibeldengan versi major 1</li></ul><p>Tentu saja, menghitung seberapa besar kompleksitas dan besarnya tim development, aturan itu tidak terlalu mengikat untuk diikuti, feel free to draw your own canvas.</p><p>Dalam konteks ini, semantic versioning bisa digunakan untuk mencatat versi dari Git Tag, Git Release , dan Build Version.</p><h3>Bump Version</h3><p>Lalu apa itu bump version? singkatnya, bump version adalah sebuah kegiatan meningkatkan (increment) versi semantic yang ada pada salah satu atau lebih dari 3 bagian versi yang ada.</p><p>Biasanya, jika sebuah pengembangan aplikasi menggunakan semantic versioning, maka developer akan melakukan bump version sesaat sebelum rilis. Hal ini secara tradisional masih dilakukan dengan cara manual</p><p>Problem dari bump version manual ada beberapa yaitu:</p><ol><li>Human-Error Prone, kesalahan yang dilakukan oleh developer seperti salah menaikkan versi, atau bahkan lupa untuk menaikkan versi.</li><li>Time-Consuming, hal-hal yang seperti ini menyita cukup banyak waktu, waktu yang bisa dialokasikan untuk hal produktif yang lain.</li><li>Inconsistency, dalam sebuah tim development yang cukup besar, proses manual bisa menyebabkan inkonsistensi jika tidak semua anggota tim mengikuti prosedur yang sama atau jika terdapat ketidaksesuaian dalam penomoran versi di berbagai bagian dari software.</li></ol><h3><strong>Automation Bump Version CI/CD</strong></h3><p>Ketika membuat sebuah automation, pastinya kita harus mendefinisikan objektif yang akan kita raih, selain itu kita harus menentukan bagian mana yang bisa diotomasi dan bagian mana yang tidak perlu. Selain itu, pemilihan tools juga sangat penting sesuai kebutuhan masing-masing.</p><p>Objektif yang akan kita raih dari automation kali ini adalah:</p><ol><li>Bump Version (incremented based on versi terakhir). Triggered by merged MR</li><li>Git Tag version baru. Triggered by merged MR</li><li>Publish release di Gitlab. Triggered by Git Tag push</li><li>Membuat changelog secara otomatis based on commit messages</li></ol><p>Platform git kali ini yang akan kita gunakan adalah Gitlab CI/CD, dan dengan tools semantic versioning open source dari <a href="https://www.npmjs.com/package/commit-and-tag-version">commit-and-tag-version</a>.</p><h3><strong>Bump Version Automation di Gitlab CI/CD</strong></h3><p>Konfigurasi CI/CD di Gitlab comes in handy, yang perlu kita siapkan hanyalah satu file bernama .gitlab-ci.yml yang kita taruh di repository dan kita isi sesuai dengan apa yang kita inginkan. (<a href="https://docs.gitlab.com/ee/ci/">docs</a>)</p><p>Ada 2 aspek yang perlu dicatat, khususnya dalam tutorial ini:</p><ol><li>Tools untuk bump version menggunakan library open source <a href="https://www.npmjs.com/package/commit-and-tag-version">commit-and-tag-version</a>.</li><li>Tracking version kita taruh di file package.json.</li></ol><h4>package.json</h4><p>File package.json yang berisi version dari aplikasi kita, dan juga dependency tools commit-and-tag-version. Selain itu, kita juga membuat npm script untuk mempersingkat dan memperjelas script command line yang akan kita gunakan di pipeline.</p><pre>{<br>    &quot;version&quot;: &quot;0.0.0&quot;,<br>    &quot;scripts&quot;: {<br>        &quot;release&quot;: &quot;commit-and-tag-version&quot;<br>    },<br>    &quot;devDependencies&quot;: {<br>        &quot;commit-and-tag-version&quot;: &quot;^12.4.1&quot;<br>    }<br>}</pre><h4>json-version-updater.js</h4><p>Kita juga membuat file bernama json-version-updater.js untuk mengupdate version yang ada di file package.json secara programatically</p><pre>const detectIndent = require(&#39;detect-indent&#39;)<br><br>module.exports.readVersion = function (contents) {<br>  return JSON.parse(contents).version;<br>}<br><br>module.exports.writeVersion = function (contents, version) {<br>  const json = JSON.parse(contents)<br>  json.version = version<br>  return JSON.stringify(json, null, detectIndent(contents).indent)<br>}</pre><ul><li>Function readVersion akan membaca field version yang ada di file package.json kita</li><li>Function writeVersion akan menulis versi terbaru ke dalam file package.json serta mengembalikan indentasi seperti sedia kala</li></ul><h4>.versionrc.js</h4><p>Kita akan menaruh seluruh konfigurasi dari tools commit-and-tag-version yang akan kita gunakan di file .versionrc.js . (<a href="https://www.npmjs.com/package/commit-and-tag-version#how-it-works">docs</a>)</p><pre>const jsonConfigFile = &#39;package.json&#39;;<br><br>const customUpdater = {<br>  filename: jsonConfigFile,<br>  type: &#39;json&#39;,<br>  updater: require(&#39;./json-version-updater&#39;),<br>};<br><br>module.exports = {<br>  header: &#39;# Changelog&#39;,<br>  types: [<br>    {<br>      type: &#39;feat&#39;,<br>      section: &#39;⚡️ Features&#39;,<br>    },<br>    {<br>      type: &#39;fix&#39;,<br>      section: &#39;🐛 Bug Fixes&#39;,<br>    },<br>  ],<br>  packageFiles: [customUpdater],<br>  bumpFiles: [customUpdater],<br>};</pre><ul><li>Header adalah judul dari file changelog.md , sesuaikan dengan kebutuhan kita.</li><li>Types adalah mapping antara commit message dan section di file chagelog.md, contoh ketika commit message adalah feat: upgrade dependency version to 1.2.2 , maka commit tersebut akan ditaruh di section 🐛 Bug Fixes.</li><li>Custom updater yang telah kita buat tadi juga kita masukkan ke dalam konfigurasi.</li></ul><h4>.gitlab-ci.yml</h4><p>Dalam membuat pipeline automation, the most basic things yang perlu kita lakukan adalah</p><ol><li>Menentukan <strong>automation stages</strong> yang akan berjalan di pipeline.</li><li>Memasukkan variable dan secret yang akan kita gunakan.</li><li>Membuat script dari tiap-tiap stage yang akan berjalan</li></ol><p>Stages yang akan kita lakukan dalam tutorial kali ini adalah:</p><ol><li><strong>Version Bump</strong> yang akan ditrigger oleh event push pada suatu branch yang telah kita proteksi dan kita target, i.e hanya merged merge request yang akan menjadi pemicunya</li><li><strong>Publish Release</strong> yang akan ditrigger oleh git tag push event</li><li><strong>Build Docker Image</strong> dengan menyisipkan tag berdasarkan versi git tag terbaru, yang juga akan ditrigger oleh git tag push event</li></ol><p>Untuk kemudahan, tahap push image baru ke image registry akan kita taruh di stage <strong>Build Docker Image.</strong></p><h4><strong>Automation Bot </strong>🤖</h4><p>Sebelum itu, kita perlu membuat akun automation bot yang akan menjalankan peran sebagai commiter dan pusher dari bump version yang akan dijalankan. Cara membuatnya cukup mudah</p><ol><li>Pergi ke halaman utama repository di Gitlab</li><li>Pilih menu <strong>Setting &gt; AccessToken </strong>di sidebar sebelah kiri</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*xBP1vVDZfJe6i74qfuUUTg.png" /></figure><p>3. Klik add new token</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D5FxtGnGqhAPioZ4t-7Kww.png" /></figure><p>4. Tentukan nama dari Bot yang akan kita buat, sertakan role, expired date, dan access control yang akan kita berikan</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E5F0C0FPuVFm75f0Z-X0zw.png" /></figure><p>5. Setelah berhasil dibuat, simpan access token yang akan digunakan dalam variabel di konfigurasi pipeline kita nantinya.</p><p>6. Untuk tahu username dari Bot, klik menu Manage &gt; Member di sidebar kiri, maka akan muncul nama kita dan nama bot, copy bagian yang ada simbol @</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mnip8b8NwHSS2Jbpu_4zVQ.png" /></figure><p>Masukkan variabel di bawah ini (sesuaikan valuenya dengan milik kalian) ke dalam variabel CI/CD. Caranya dengan memilih menu Setting &gt; CI/CD &gt; Variables</p><pre>DOCKER_IMAGE: go-cicd # nama dari docker image<br>CI_REGISTRY: registry.hub.docker.com # host image registry<br>DOCKERHUB_USER: rullyafrzl<br>DOCKERHUB_PASSWORD: dockerhubPassword # username dan password image registry<br><br># username dari ci bot<br>CI_USER: project_57620815_bot_21b184e150833353b64280f8a77aae8c<br><br># Access token dari ci bot<br>CI_USER_ACCESS_TOKEN: accessToken<br><br># url repository<br>GIT_URI: gitlab.com/rullyafrzl/cicd-tutorial </pre><ol><li><strong>Stages</strong></li></ol><pre>stages:<br>  - version_bump<br>  - release<br>  - build_image</pre><p><strong>2. Automation Script</strong></p><ul><li>Bump Version</li></ul><pre>.version_bumping: &amp;version_bumping<br>  stage: version_bump<br>  image: timbru31/node-alpine-git:18<br>  #default rules<br>  rules:<br>    - if: &#39;$GITLAB_USER_LOGIN != $CI_USER &amp;&amp; $CI_PIPELINE_SOURCE == &quot;push&quot;&#39;<br>  before_script:<br>    - npm ci<br>    - git config --global user.email $CI_EMAIL<br>    - git config --global user.name $CI_USER<br>    - git config receive.advertisePushOptions true<br>    - git config --global http.sslVerify false<br>    - git checkout -B &quot;$CI_COMMIT_REF_NAME&quot; &quot;$CI_COMMIT_SHA&quot;<br>  #default script<br>  script:<br>    - npm run release -- --prerelease dev<br>    - git push https://${CI_USER}:${CI_USER_ACCESS_TOKEN}@${CI_GIT_URI} --follow-tags $CI_COMMIT_BRANCH:$CI_COMMIT_BRANCH<br><br># dev job in merge-request is merged into develop<br>version-bump-dev:<br>  &lt;&lt;: *version_bumping<br>  rules:<br>    - if: &#39;$GITLAB_USER_LOGIN != $CI_USER &amp;&amp; $CI_PIPELINE_SOURCE == &quot;push&quot; &amp;&amp; $CI_COMMIT_REF_NAME == &quot;develop&quot;&#39;<br>  script:<br>    - npm run release -- --prerelease dev<br>    - git push https://${CI_USER}:${CI_USER_ACCESS_TOKEN}@${CI_GIT_URI} --follow-tags $CI_COMMIT_BRANCH:$CI_COMMIT_BRANCH<br><br># master job when merge-request is merged into main<br>version-bump-main:<br>  &lt;&lt;: *version_bumping<br>  #override rules<br>  rules:<br>    - if: &#39;$GITLAB_USER_LOGIN != $CI_USER &amp;&amp; $CI_PIPELINE_SOURCE == &quot;push&quot; &amp;&amp; $CI_COMMIT_REF_NAME == &quot;main&quot;&#39;<br>  #override script<br>  script:<br>    - npm run release -- --no-verify<br>    - git push https://${CI_USER}:${CI_USER_ACCESS_TOKEN}@${CI_GIT_URI} --follow-tags $CI_COMMIT_BRANCH:$CI_COMMIT_BRANCH<br><br># Dry run in merge request, to check if the bump version will success or not before we merge it<br>version-bump-dry-run:<br>  &lt;&lt;: *version_bumping<br>  rules:<br>    - if: &#39;$GITLAB_USER_LOGIN != $CI_USER &amp;&amp; $CI_PIPELINE_SOURCE == &quot;merge_request_event&quot; &amp;&amp; $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == &quot;develop&quot;&#39;<br>  script:<br>    - npm run release -- --dry-run</pre><p>Kita akan menggunakan image dari <strong>timbru31/node-alpine-git</strong>, karena kita membutuhkan satu image yang memiliki nodejs dan git sekaligus di dalamnya. Kalau ingin menggunakan image sendiri juga silahkan, pastikan ukurannya kecil, dan terdapat nodejs (npm) dan git di dalamnya.</p><p>Terdapat 3 bagian dari version bump script, yaitu:</p><ol><li><strong>version-bump-dev</strong> akan berjalan ketika merged MR ke branch develop</li><li><strong>version-bump-main</strong> akan berjalan ketika merged MR ke branch main</li><li><strong>version-bump-dry-run</strong> akan berjalan ketika merge request</li></ol><p>Jangan lupa untuk menambahkan kondisi $GITLAB_USER_LOGIN != CI_NAME untuk menghindari infinite loop, akan saya jelaskan di akhir artikel ini bagaimana infinite loop bisa terjadi apabila tidak memasukkan kondisi tersebut.</p><ul><li>Publish Release</li></ul><pre>release:<br>  stage: release<br>  image: registry.gitlab.com/gitlab-org/release-cli<br>  rules:<br>    - if: $CI_COMMIT_TAG<br>  script:<br>    - echo &quot;running release_job for $CI_COMMIT_TAG&quot;<br>  release:                               <br>    tag_name: &#39;$CI_COMMIT_TAG&#39;<br>    description: &#39;$CI_COMMIT_TAG&#39;<br>    ref: &#39;$CI_COMMIT_SHA&#39;</pre><ul><li>Build Docker Image</li></ul><pre>build_image:<br>  stage: build_image<br>  image: docker:20.10.16<br>  services:<br>    - docker:20.10.16-dind<br>  script:<br>    - docker login -u $DOCKER_HUB_USERNAME -p $DOCKER_HUB_PASSWORD<br>    - docker build -t $DOCKER_IMAGE:$CI_COMMIT_TAG .<br>    - docker tag $DOCKER_IMAGE:$CI_COMMIT_TAG $DOCKERHUB_USER/$DOCKER_IMAGE:$CI_COMMIT_TAG<br>    - docker push $DOCKERHUB_USER/$DOCKER_IMAGE:$CI_COMMIT_TAG<br>  only:<br>    - tags</pre><p>Keseluruhan file .gitlab-ci.yml</p><pre>stages:<br>  - version_bump<br>  - release<br>  - build_image<br><br># template<br>.version_bumping: &amp;version_bumping<br>  stage: version_bump<br>  image: timbru31/node-alpine-git:18<br>  #default rules<br>  rules:<br>    - if: &#39;$GITLAB_USER_LOGIN != $CI_USER &amp;&amp; $CI_PIPELINE_SOURCE == &quot;push&quot;&#39;<br>  before_script:<br>    - npm ci<br>    - git config --global user.email $CI_EMAIL<br>    - git config --global user.name $CI_USER<br>    - git config receive.advertisePushOptions true<br>    - git config --global http.sslVerify false<br>    - git checkout -B &quot;$CI_COMMIT_REF_NAME&quot; &quot;$CI_COMMIT_SHA&quot;<br>  #default script<br>  script:<br>    - npm run release -- --prerelease dev<br>    - git push https://${CI_USER}:${CI_USER_ACCESS_TOKEN}@${CI_GIT_URI} --follow-tags $CI_COMMIT_BRANCH:$CI_COMMIT_BRANCH<br><br># dev job in merge-request<br>version-bump-dev:<br>  &lt;&lt;: *version_bumping<br>  rules:<br>    - if: &#39;$GITLAB_USER_LOGIN != $CI_USER &amp;&amp; $CI_PIPELINE_SOURCE == &quot;push&quot; &amp;&amp; $CI_COMMIT_REF_NAME == &quot;develop&quot;&#39;<br>  script:<br>    - npm run release -- --prerelease dev<br>    - git push https://${CI_USER}:${CI_USER_ACCESS_TOKEN}@${CI_GIT_URI} --follow-tags $CI_COMMIT_BRANCH:$CI_COMMIT_BRANCH<br><br># master job when merge-request is accepted into main<br>version-bump-main:<br>  &lt;&lt;: *version_bumping<br>  #override rules<br>  rules:<br>    - if: &#39;$GITLAB_USER_LOGIN != $CI_USER &amp;&amp; $CI_PIPELINE_SOURCE == &quot;push&quot; &amp;&amp; $CI_COMMIT_REF_NAME == &quot;main&quot;&#39;<br>  #override script<br>  script:<br>    - npm run release -- --no-verify<br>    - git push https://${CI_USER}:${CI_USER_ACCESS_TOKEN}@${CI_GIT_URI} --follow-tags $CI_COMMIT_BRANCH:$CI_COMMIT_BRANCH<br><br># Dry run in merge request<br>version-bump-dry-run:<br>  &lt;&lt;: *version_bumping<br>  rules:<br>    - if: &#39;$GITLAB_USER_LOGIN != $CI_USER &amp;&amp; $CI_PIPELINE_SOURCE == &quot;merge_request_event&quot; &amp;&amp; $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == &quot;develop&quot;&#39;<br>  script:<br>    - npm run release -- --dry-run<br><br>build_image:<br>  stage: build_image<br>  image: docker:20.10.16<br>  services:<br>    - docker:20.10.16-dind<br>  script:<br>    - docker login -u $DOCKER_HUB_USERNAME -p $DOCKER_HUB_PASSWORD<br>    - docker build -t $DOCKER_IMAGE:$CI_COMMIT_TAG .<br>    - docker tag $DOCKER_IMAGE:$CI_COMMIT_TAG $DOCKERHUB_USER/$DOCKER_IMAGE:$CI_COMMIT_TAG<br>    - docker push $DOCKERHUB_USER/$DOCKER_IMAGE:$CI_COMMIT_TAG<br>  only:<br>    - tags<br><br>release:<br>  stage: release<br>  image: registry.gitlab.com/gitlab-org/release-cli<br>  rules:<br>    - if: $CI_COMMIT_TAG<br>  script:<br>    - echo &quot;running release_job for $CI_COMMIT_TAG&quot;<br>  release:                               <br>    tag_name: &#39;$CI_COMMIT_TAG&#39;<br>    description: &#39;$CI_COMMIT_TAG&#39;<br>    ref: &#39;$CI_COMMIT_SHA&#39;</pre><p>Ketika kita coba jalankan npm run release di local akan muncul seperti ini:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qdB_w1GuL58iXLmX39_9ZA.png" /></figure><p>Setidaknya itulah ekspektasi yang akan terjadi di pipeline kita nantinya</p><h3>Execution 🚀</h3><p>Semua konfigurasi telah kita siapkan, saatnya kita eksekusi</p><ol><li>Push code kita ke gitlab dengan branch baru</li><li>Buat Merge Request dengan target branch develop</li><li>Pastikan version-bump-dry-run berjalan saat merge request telah kita buat</li><li>Merge MR yang telah kita buat, pipeline bump-version akan secara otomatis berjalan. Sedangkan untuk pipeleine release dan build image akan berjalan setelah pipeline bump version telah selesai.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ckjcNL_DzrBr9pqtllsUMQ.png" /></figure><p>5. All done 🚀</p><h3>Infinite Loop ♾️</h3><p>Untuk memahami alasan utama kita menggunakan kondisi $GITLAB_USER_LOGIN != $CI_USER mari kita pahami behind the scene yang terjadi.</p><ol><li><strong>CI_USER</strong> valuenya selalu sama, karena ini adalah variabel yang sebelumnya telah kita set</li><li>Seseorang yang menekan tombol merge di sebuah MR, akan menjadi <strong>GITLAB_USER_LOGIN</strong> pada pipeline bump-version</li><li>Pipeline bump version berjalan dengan menaikkan versi dengan menggunakan tools <strong>commit-and-tag-version </strong>dan melakukan <strong>git push — follow-tags </strong>dengan menggunakan identitas CI Bot yang telah kita buat</li><li>Pipeline publish release dan build image akan berjalan karena terdapat trigger git push yang baru</li></ol><p>Coba baca dan renungkan semua step di atas, temukan di mana terdapat kesalahan apabila kita tidak menggunakan kondisi $GITLAB_USER_LOGIN != $CI_USER .</p><p>Jawabannya perhatikan pada poin ke-3 dan pahami bahwa trigger dari pipeline bump version adalah <strong>push events. </strong>Ketika CI Bot melakukan push bersamaan dengan tag baru ke branch tersebut, maka otomatis pipeline bump version akan triggered again, dan begitu seterusnya hingga kita dapat infinite loop.</p><p>Saya sendiri sudah pernah mengalami hingga tidak sengaja push ke image registry terlalu banyak dan free CI/CD time limit yang ada di akun Gitlab habis tak bersisa 😅</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/701/1*qG7YWaY5T8ng-HrYJFTDnw.png" /><figcaption>Lesson Learned :(</figcaption></figure><h3><strong>Summary</strong></h3><p>Objektif apa saja yang telah kita raih?</p><ol><li>Bump Version (incremented based on versi terakhir). Triggered by merged MR ✅</li><li>Git Tag version baru. Triggered by merged MR ✅</li><li>Publish release di Gitlab. Triggered by Git Tag push ✅</li><li>Membuat changelog secara otomatis based on commit messages ✅</li></ol><p>Salah satu tugas yang sering kali menyita waktu adalah bump version pada aplikasi atau library yang kita kembangkan. Proses ini, meskipun tampak sederhana, memerlukan perhatian dan ketelitian untuk memastikan tidak ada kesalahan dalam penentuan versi yang dapat menyebabkan masalah di masa depan. Dengan mengotomasi proses ini, kita bisa mengurangi risiko human error dan menghemat banyak waktu yang bisa digunakan untuk tugas-tugas yang lebih kritis dan memerlukan pemikiran mendalam.</p><p>Sekian, terima kasih ☕️.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2edff03b4e73" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[On-Call Rotation]]></title>
            <link>https://rullyafrzl.medium.com/on-call-rotation-730b566b9836?source=rss-e490a8bef557------2</link>
            <guid isPermaLink="false">https://medium.com/p/730b566b9836</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[monitoring]]></category>
            <category><![CDATA[on-call-rotation]]></category>
            <category><![CDATA[on-call]]></category>
            <category><![CDATA[postmortem]]></category>
            <dc:creator><![CDATA[Rully Afrizal]]></dc:creator>
            <pubDate>Sat, 09 Dec 2023 15:00:39 GMT</pubDate>
            <atom:updated>2023-12-09T15:00:39.040Z</atom:updated>
            <content:encoded><![CDATA[<p>Hari senin tanggal 10 Oktober 2022, itu adalah hari di mana pertama kali gw dapet jatah <em>shift on-call </em>di company sebelumnya, setelah seminggu sebelumnya 1on1 dengan direct report gw di mana dia ngejelasin apa itu on-call and how to play the on-call shift seperti biasa yang dilakuin engineer2 lain.</p><p>Beberapa kalimat yang gw masih inget kurang lebih gini, “kita belajar banyak justru waktu debugging”, “monitoring 24x7 and act immediately kalau ada yang raise issue production, during work hours kalau issuenya di staging”, “pastiin acknowledge as soon as the issue raised dulu, jangan pas udah ketemu rootcausenya baru acknowledge”. Bayangin gimana ketar-ketirnya anak kemaren sore yang belum ngerti apa-apa, harus monitoring 3 produk 24x7 selama seminggu, sendirian.</p><p>Jujur waktu itu yang gw persiapin cuman dengan baca-baca dokumentasi di confluence, dan ngeliat gimana engineer lain handle issue waktu lagi on-call di slack, dengan persiapan itu ternyata gw bisa lewatin 4 hari tanpa big major issue, cuma laporan2 kecil yang terselesaikan dengan mudah dan bisa dibilang gaada impact ke major customers, atau bahkan mungkin ga di-notice sama customers. Kalo kata orang, “kalo hidup lempeng2 aja tuh berarti pertanda ada yang aneh di depan nih ntar liat aja”.</p><p>14 Oktober 2022 outside working hours sekitar jam 7 malam, alert gagal transaksi yang kita pasang di slack buat monitoring firing terus menerus, notifikasi slack yang khas dan bikin kita dagdigdugser bunyi ga berenti2, panik dan yang gw lakuin waktu itu cuman ngecek log di kibana, in parallel team dari noc (network operation center) announce di channel slack bahwa lagi ada flooding alert dan mereka confirm ke gw sebagai on-call “is this an outage?”, ga langsung gw jawab karena gw bahkan ga ngerti, sambil panik di kepala gw bertanya2 “yang considered outage itu yang kaya gimana???”. Akhirnya berujung gw cuman sodorin hasil temuan dari log, “there is a failure from the (vendor) API”, di situ manajer gw untungnya langsung nimbrung dan manggil devops.</p><p>Selang beberapa menit, war room dibuat dan kita semua join, gw ditanyain lagi “is this an outage?”, gw akhirnya jawab “yes this one pretty sure is an outage”, dan akhirnya mereka announce di channel khusus outage bahwa sedang terjadi outage di salah satu produk, yang terjadi ketika customer ngelakuin transaksi. Di situ gw “oh mereka nanyain ini buat di-announce di channel toh”.</p><p>Lanjut di war room, devops nanyain gimana errornya, gw jawab kalau ada connection failure dari kita ke pihak vendor, minta tolong buat dicek ini kesalahan ada di sisi kita atau errornya emang dari mereka, devops gaada yang tau gimana cara buat masuk ke routernya (nb devops rata2 orang baru, yang setup semua network ini orang2 lama yang udah resign wkwk), jadi kita harus nunggu orang dari IT support buat bantuin, in parallel mereka ngejelasin gimana route network dari kita sampai ke sisi mereka, menurut gw cukup keren karena emang cukup ga biasa denger model yang macam kaya gini, alasannya sih kata mereka ada regulasi dan terkait dengan security makanya dibikin model sedemikian rupa. Waktu orang IT support dateng dan benerin, issue fixed dan alert yang muncul di slack udah berhenti, dan confirmed bahwa problemnya ada di sisi kita.</p><p>Abis issuenya kelar dan fixed, manajer gw bilang “rul minta tolong buat bikinin postmortem kejadian tadi ya”, di situlah pertama kalinya gw bikin yang namanya RCA alias postmortem, dapet ilmu baru meskipun postmortem yang gw bikin waktu itu bisa dibilang masih jelek banget, yah namanya juga beginner. Gw serahin postmortem yang udah gw bikin di hari senin pagi, dan itulah akhir dari cerita pengalaman on-call pertama gw.</p><p>For the record, kisah selanjutnya adalah improvement2 terjadi buat mekanisme on-call di tim gw maupun dari gw sendiri, mulai dari SOP yang musti dilakuin waktu on-call, sampe SLO (Service Level Objective) yang harus dicapai tiap engineer waktu on-call, semua itu dilakuin karena emang sebelumnya kita gaada mekanisme buat handle issue yang bener waktu on-call. Dari yang sebelumnya kita ~1 jam buat acknowledge issue (on-average), jadi ~8 minutes after the issue being raised, on-call juga gak sendirian lagi, ada 2 orang, junior dan senior, junior wajib jadi primary on-call, dan senior jadi backup (secondary). Dan kalau ada postmortem yang dibuat bakal direview bareng2 sama tim, dari situ gw ngeliat senior2 gw juga masih banyak kesalahan waktu bikin postmortem, hats off kepada manajer gw yang ngerancang mekanisme baru ini, keren.</p><p>Akhir-akhir ini gw mulai nyadar bahwa keterlibatan secara end-to-end inilah yang menjadikan salah satu penyebab engineer punya feeling ownership sama product yang dia craft and built.</p><p>Dalam kepala gw mikir “Oh ini ya kenapa gw denger banyak cerita bahwa engineer di company2 gede kaya Google, Meta, dll. mereka terlibat dari proses end-to-end, bahkan ada juga yang gaada dedicated QA yang buat ngecek kerjaan mereka, terus yang ngelakuin QA siapa? ya engineernya sendiri”.</p><p>Sayangnya feeling ownership itu gaada di product yang lagi gw kembangkan di company gw yang baru sekarang, karena emang engineer cuman sampe tahap deploy aja, dan kebanyakan orang di sini view the development as a project not a product.</p><p>Terakhir, gw ada kutipan bagus dari salah satu artikel medium yang gw temuin, bunyinya gini:</p><blockquote>Service developers need to be responsible for not just writing code but also for managing the entire life-cycle of the service, ensuring its health, maintainability, observability, ease of debugging and its ultimate graceful demise. This includes being responsible for deployments, rollbacks, monitoring and debugging, in addition to bug fixes and new feature development.</blockquote><blockquote>We’re looking at a future where responsibilities are <em>shared</em>. Operations, per se, is <em>not </em>everyone’s job. What, however, <em>is</em> everyone’s job is ensuring holistic software lifecycle, achieved when SWEs and SREs work together. And the first step toward this future is to actually have a healthy respect for Operations and on-call (even if developers personally don’t find it “fun”), and statements along the lines of “I’m a brilliant developer but I hate on-call” aren’t doing the cause any favors.</blockquote><blockquote><strong>Cindy Sridharan</strong></blockquote><p>Catatan terakhir (aka pamer), manajer gw pasang metrics buat on-call response time dari tiap2 engineer, dan dia bilang kalo gw ada di angka ~1 menit (acknowledge time), damn bahkan gw sendiri juga kaget :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=730b566b9836" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Root Cause Analysis (RCA) 101]]></title>
            <link>https://rullyafrzl.medium.com/root-cause-analysis-rca-101-4f0b14ca490f?source=rss-e490a8bef557------2</link>
            <guid isPermaLink="false">https://medium.com/p/4f0b14ca490f</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[rca]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[postmortem-documentation]]></category>
            <dc:creator><![CDATA[Rully Afrizal]]></dc:creator>
            <pubDate>Sat, 22 Jul 2023 03:10:42 GMT</pubDate>
            <atom:updated>2023-07-22T03:14:52.773Z</atom:updated>
            <content:encoded><![CDATA[<p>Perkembangan software modern menjadi semakin kompleks, <em>and complex system means we have to go and dive deep</em>. Arsitektur dan infrastruktur software yang semakin rumit tentu saja akan berdampak terhadap meningkatnya <em>margin of error</em>. Bahkan dengan perancangan yang matang, testing yang <em>covering</em> semua <em>edge case</em>, <strong><em>incident and failure is inevitable</em></strong>.</p><p>Definisi dari insiden sendiri dalam software adalah ketika behavior dari software tersebut tidak berjalan sesuai dengan ekspektasi. Ketika arsitektur dan infrastuktur software sudah tumbuh menjadi kompleks, kemungkinan terjadinya insiden akan meningkat sangat tinggi. Disinilah peran dari Root Cause Analysis sebagai bagian dari incident response and management dibutuhkan.</p><h4>Mengapa ini perlu?</h4><p>Kalau ditarik dari definisi insiden yang sudah saya paparkan, besar kemungkinan insiden ini dapat menyebabkan downtime pada software yang kita buat, dan downtime sendiri cukup “mahal” dalam konteks kepuasan customer, business image, dan bahkan dalam arti literalnya yaitu duit a.k.a revenue loss.</p><blockquote>Setiap insiden adalah cobaan bagi engineer on-call :), tetapi juga menjadi sebuah kesempatan untuk belajar. A wise man once said, we learn from embracing mistakes and failure.</blockquote><p>Dengan analisis yang baik harapannya adalah kita bisa melihat dan memandang sesuatu dari sudut lain sehingga kita bisa mengetahui apa yang belum kita ketahui, <strong><em>knowing what you don’t know and knowing that we don’t know what we don’t know. </em></strong>Untuk membangun software yang robust dikemudian hari, <em>trial and error is invitable. A</em>spek terpenting adalah kita bisa belajar dari kesalahan lalu untuk membangun masa depan yang lebih baik.</p><p>Mungkin sebagai orang yang menangani insiden yang sudah terjadi, kita bisa merasa paham terhadap root-cause dari insiden tersebut tanpa membuat dokumen analisis. Tapi ingat bahwa kita bekerja sebagai tim, dan anggota tim lain berhak untuk sama-sama memiliki pemahaman tersebut, yang berujung kepada kontribusi terhadap tim dan customer. Bahkan cloudflare, penyedia layanan keamanan, performa, dan pengoptimalan untuk website yang sangat terkenal rutin membagikan Root Cause Analysis mereka setelah terjadi insiden, hal ini sangat baik untuk kepercayaan customer pengguna Cloudflare sendiri dan sebagai akuntabilitas terhadap apa yang mereka kerjakan.</p><h4>Incident Management</h4><p>Sebelum kita berbicara tentang analisis yang menjadi bagian dari incident management, mari kita bicara tentang incident management itu sendiri. Insiden manajemen memiliki fase yang harus diperhatikan yaitu:</p><ol><li><strong>Detection</strong></li></ol><p>Deteksi adalah langkah awal dari insiden manajemen, dengan memasang metode deteksi yang bagus, kita bisa mengetahui insiden dan memitigasinya dengan cepat. Biasanya deteksi bisa dalam bentuk alert, monitoring, dan laporan.</p><p><strong>2. Response</strong></p><p>Pastikan setelah kita mendeteksi sebuah insiden, sesegera mungkin respon insiden tersebut. Inilah biasanya tugas dari seorang on-call engineer.</p><p><strong>3. Resolution</strong></p><p>Fase ini adalah fase penyelesaian masalah, dimana kita mencari root cause dari insiden yang terjadi dan melakukan perbaikan secara langsung.</p><p><strong>4. Analysis</strong></p><p>Setelah insiden sudah selesai dan resolved, artinya saatnya kita membuat analisis terhadap akar masalah atau root cause yang menyebabkan insiden bisa terjadi. Inilah yang kita sebut dengan RCA atau post-mortem</p><p><strong>5. Remedy</strong></p><p>Setelah analisis maka langkah terakhir dan kita sudah belajar dari kesalahan di masa lalu, maka langkah selanjutnya adalah mempersiapkan masa depan dengan persiapan yang lebih matang.</p><h4>Root Cause Analysis</h4><p>Seperti namanya, objektif dari analisis ini adalah untuk mengetahui akar permasalahan yang menyebabkan sebuah insiden terjadi. Yang artinya kita perlu go deep and dive deep untuk memenukan sebuah akar permasalahan. Metode yang cukup terkenal digunakan untuk menggambarkan akar permasalahan dengan clear dan deep adalah dengan menggunakan metode 5 why, atau menanyakan 5 pertanyaan yang diawali dari kata why terhadap sebuah permasalahan yang terjadi.</p><p><strong>Why user can’t open their profile page?</strong></p><ul><li>Because we’re having a problem with our profile service</li></ul><p><strong>Why we’re having a problem with our profile service?</strong></p><ul><li>Because there is a problem in connection to database that is used in profile service</li></ul><p><strong>Why there is a connection problem to database?</strong></p><ul><li>Because we put the wrong database configuration in the last profile service deployment</li></ul><p><strong>Why we put wrong database configuration in profile service in the last deployment?</strong></p><ul><li>Because we do not have a clear SOP to configure something in the deployment phase, hence this configuration thing is often missed</li></ul><p><strong>Why is there no clear SOP (Standard Operating Procedure) for configuring something in the deployment phase?</strong></p><ul><li>Because there was no established process for creating and maintaining SOPs in our development and deployment practices.</li></ul><p>Perlu diperhatikan bahwa jumlah pertanyaan yang harus muncul dalam metode ini tidak harus 5. Ketika sebuah root cause ditemukan pada jawaban di pertanyaan ketiga, maka itulah root cause-nya, atau kadang kita butuh lebih dari 5 untuk benar-benar mengetahui akar permasalahan.</p><h4>Hal-hal yang perlu diperhatikan</h4><p>Mencari sebuah akar permasalahan yang terjadi pada sebuah insiden yang sistemnya dibangun oleh teamwork, akan sangat rentan terjadinya saling menyalahkan antar anggota tim, hal ini akan berdampak kepada kinerja tim kedepannya. Beberapa tips yang bisa diperhatikan adalah:</p><p><strong>Blameless Culture</strong></p><p><em>Stop pointing finger</em>, berhenti menyalahkan seseorang terhadap masalah yang dia buat. Akan jauh lebih bermanfaat apabila kita langsung fokus pada solusi dari insiden yang terjadi dan memastikan seluruh anggota tim bisa belajar dari kesalahan yang kita buat bersama-sama.</p><p>Dalam dokumen analisis yang kita buat, hindari kata-kata atau kalimat yang berujung menyalahkan seseorang secara spesifik. Kita bisa gunakan diksi yang tidak menarget satu orang secara spesifik terhadap sebuah kesalahan.</p><p><strong>Put Prioritization</strong></p><p>Tidak semua insiden perlu immediate fixing atau perbaikan secara langsung, pilah dan pilih insiden yang menurutmu cukup berdampak terhadap kepuasan user, durasi downtime, dan kemungkinan <em>revenue loss</em> yang terjadi. Biasa gunakan P0, P1, P2, dan seterusnya, semakin kecil angkanya maka semakin besar dampaknya, <em>always prioritze P0 first</em>.</p><p><strong>Share Analysis</strong></p><p>Setelah analisis <em>root cause</em> sudah jadi, biasakan untuk share ke rekan kerja agar mereka aware terhadap temuan apapun yang kita lakukan terhadap insiden tersebut sehingga sebagai team kita bisa belajar sama-sama terhadap sebuah kesalahan. Jangan lupa untuk minta masukan dan approval dari atasan atau rekan kerja dari analisis yang telah kita buat.</p><h4>Kesimpulan</h4><p>Pada akhirnya, sebuah software yang tumbuh menjadi lebih kompleks memerlukan metode yang kokoh untuk menangani insiden yang terjadi, karena memang kemungkinan terjadinya insiden bukanlah kemungkinan kecil apabila sistem sudah semakin kompleks. “<em>When that happen and how do we handle it</em>” adalah pertanyaan pentingnya.</p><p><em>Embrace failure as an opportunity for learning</em>, daripada kita fokus takut pada insiden itu sendiri, lebih baik takut ketika tidak dapat pelajaran apa-apa dari insiden yang terjadi. <em>Failure is inevitable</em>, dengan menerapkan post-mortem analysis yang bagus dan efektif akan menjadi benefit untuk mempersiapkan tantangan besar lain kedepannya.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f0b14ca490f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mekanisme Locking Sebagai Solusi Concurrency Control dengan Menggunakan Redis]]></title>
            <link>https://rullyafrzl.medium.com/redis-locking-mechanism-sebagai-concurrency-control-245b1b735ed9?source=rss-e490a8bef557------2</link>
            <guid isPermaLink="false">https://medium.com/p/245b1b735ed9</guid>
            <category><![CDATA[redis]]></category>
            <category><![CDATA[locking]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Rully Afrizal]]></dc:creator>
            <pubDate>Sun, 25 Jun 2023 02:42:45 GMT</pubDate>
            <atom:updated>2023-06-25T08:33:27.840Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B-jAV2brcnAfgBK_hAdGKw.png" /></figure><p>Ketika sedang mempelajari lebih jauh tentang mekanisme caching lock yang diimplementasikan di tempat saya bekerja, saya menjadi terinspirasi untuk menulis secara singkat tentang ini sebagai bahan belajar. Dalam tulisan kali ini, saya akan mencoba untuk menjelaskan tentang locking mechanism yang kita bisa lakukan dengan menggunakan Redis.</p><h4>Redis dan Caching</h4><p>Redis adalah sebuah In-Memory Data Storage yang bisa digunakan sebagai Caching Storage dan Pub/Sub Broker (Messaging). Penggunaan Redis untuk caching pada aplikasi yang dibuat di era sekarang sudah cukup umum, bahkan pilihan atau ingatan pertama yang muncul dalam pikiran ketika berbicara tentang in-memory caching tentu saja Redis.</p><p>Caching sendiri singkatnya adalah sebuah proses untuk menyimpan data dengan mekanisme tertentu agar bisa diakses dalam waktu yang lebih cepat relatif terhadap penyimpanan non-cached. Apabila pembaca dari tulisan ini adalah Software Engineer yang pekerjaannya adalah membuat aplikasi, maka penggunaan caching yang terlintas dan paling umum dalam pikiran adalah bagaimana cara untuk mengurangi network call ke database sehingga proses retrieval data yang cukup besar dan sering dilakukan dapat menjadi lebih efisien. Untuk memperluas pandangan, pada realitanya banyak sekali use-case lain dari caching, semua proses yang berhubungan dengan data retrieval atau pengambilan data akan selalu bisa di-cache untuk mempercepat proses.</p><h4>Locking</h4><p>Dalam konteks development aplikasi yang scalable, implementasi mekanisme locking menjadi semakin penting untuk memastikan correctness and consistency data. Tanpa mekanisme ini, terdapat risiko tinggi terjadinya race condition, di mana multiple request saling berebut untuk mengakses sumber daya/resource yang sama secara bersamaan.</p><p>Mekanisme locking dapat diterapkan pada berbagai tingkatan dalam arsitektur aplikasi. Salah satu contoh penggunaannya adalah pada level database, di mana locking digunakan untuk memastikan bahwa operasi yang dilakukan oleh satu transaksi tidak terganggu oleh transaksi lain yang berusaha mengakses atau memodifikasi data yang sama. Dalam hal ini, mekanisme locking digunakan untuk mengontrol akses konkurensi ke data dan memastikan bahwa operasi transaksi dilakukan secara terurut dan terisolasi.</p><p>Selain itu, mekanisme locking juga sering digunakan dalam sistem caching untuk menghindari masalah yang disebabkan oleh konsistensi data. Dalam skenario caching, ketika sebuah data diminta, sistem akan mencoba mencarinya di cache terlebih dahulu sebelum mengakses sumber data asli, seperti database. Jika data tersebut ada di cache, maka proses pengambilan data menjadi lebih cepat. Namun, jika beberapa request datang secara bersamaan dan mencoba mengambil data yang sama yang belum tersedia di cache, maka <strong>mekanisme locking akan digunakan untuk memastikan hanya satu request yang mengakses sumber data asli dan melakukan proses caching</strong>. Hal ini menghindari duplikasi pengambilan data dan memastikan konsistensi data yang ditampilkan kepada pengguna.</p><h4>Mengapa Harus Locking</h4><p>Tujuan utama dari penggunaan locking adalah efisiensi dan correctness.</p><ol><li>Dalam hal <strong>efisiensi</strong>, kita mencoba untuk menghemat computational process yang terjadi apabila beberapa request datang untuk melakukan proses yang sama dalam waktu yang hampir bersamaan. Dengan meloloskan 1 request dan membuat request lain menunggu, kita bisa memastikan bahwa dari semua “similar request” yang datang cukup satu saja yang kita proses dan membagi hasilnya pada semua “similar request” yang datang. Hal ini berdampak pada computational cost, terutama kalau proses tersebut seperti query ke database, outbound call ke service lain, dan lain sebagainya yang pada intinya cukup mahal apabila dilakukan dengan berulang-ulang.</li><li>Dalam hal <strong>correctness</strong>, kita ingin memastikan bahwa antar request satu sama lain yang datang secara bersamaan tidak saling berebut untuk melakukan proses yang sama dan membuat state atau keadaan dari aplikasi kita menjadi kacau i.e race conditions.</li></ol><h4>Mekanisme Locking Dalam Konteks Data Retrieval</h4><p>Langsung saja kita bahas mengenai mekanisme locking sendiri menggunakan Redis dalam konteks data retrieval. Disclaimer pada tulisan kali ini kita berfokus pada mekanisme locking dengan bantuan Redis dan kita menggunakan single instance Redis.</p><p>Pertama saya jelaskan dulu skenario caching tanpa locking. Bayangkan apabila kita memiliki 2 client (client A dan B) yang sedang melakukan request ke sebuah Service exporter untuk mendapatkan data rekap sebuah financial report, dalam fitur export data rekap ini diimplementasikan sebuah caching (tanpa lock) karena data rekap ini akan sering diambil sehingga proses computational dan query ke DB menjadi lebih jarang sehingga menghemat proses yang “mahal”.</p><pre>function exportData() {<br>  var data = getDataFromCache();<br>  if (data == null) {<br>    data = getDataFromDatabase();<br>    processData(data);<br>    putDataToCache(data);<br><br>    return buildExcelReport(data);<br>  }<br>  <br>  return buildExcelReport(data);<br>}</pre><ol><li>Client A melakukan request export data</li><li>Service exporter menerima request Client A</li><li>Service exporter memproses request Client A dengan mencoba untuk mengecek data di cache dan tidak ketemu, sehingga melanjutkan untuk mengambil data dari database dan memproses data tersebut sebelum dikirim ke client (dalam kasus request A ini pengambilan data dari database dan pemrosesannya memakan waktu kurang lebih 20 detik)</li><li>Service exporter belum selesai memproses request dari Client A, Client B melakukan request export data</li><li>Service exporter menerima request Client B</li><li>Service exporter memproses request Client B dengan mencoba untuk mengecek data di cache dan tidak ketemu, sehingga melanjutkan untuk mengambil data dari database dan memproses data tersebut sebelum dikirim ke client.</li><li>Service exporter selesai melakukan pemrosesan data untuk request A, menaruh hasil di cache untuk digunakan pada request berikutnya, dan memproses untuk mengembalikan hasil ke Client A.</li><li>Service exporter selesai melakukan pemrosesan data untuk request B, menaruh hasil di cache untuk digunakan pada request berikutnya, dan memproses untuk mengembalikan hasil ke Client A.</li></ol><p>Dari step yang saya jelaskan, terdapat hal yang bisa kita hemat yaitu pengambilan data dari database dan pemrosesannya, request dari Client A dan B menginginkan hasil yang sama, kita tidak perlu melakukan 2 kali panggilan ke database.</p><p>Namun, dengan menggunakan mekanisme locking, langkah-langkahnya akan sedikit berbeda:</p><pre>function exportDataWithLocking() {<br>  var data;<br>  bool isLockFlagAcquired = acquireLockFlag(key);<br>  if (!isLogFlagAcquired) {<br>    // implement wait and retry to fetch the data from cache<br>    waitAndRetryToFetchDataFromCache(key);<br>    // when data is already available, proceed to buildExcelReport<br>    ...<br>  } else {<br>    bool isDataAvailableInCache = checkIfDataIsAvailableInCache();<br><br>    if (isDataAvailableInCache) {<br>      // proceed to buildExcelReport with the data from cache<br>      ...<br>    }<br><br>    data = getDataFromDatabase();<br>    processData(data);<br>    putDataToCache(data);<br>    evictLockFlag(key);<br>    // proceed to buildExcelReport with the processed data;<br>    ...<br>  }<br>  <br>}</pre><ol><li>Client A melakukan request export data ke service exporter.</li><li>Service exporter menerima dan memproses request dari client A.</li><li>Service exporter membuat Lock Flag dengan command <a href="https://redis.io/commands/setnx/"><strong>SETNX</strong></a><strong> </strong>pada Redis.</li><li>Apabila Lock Flag tidak berhasil didapatkan, artinya sedang ada proses lain sebelum request dari Client A yang melakukan request export data, dalam kasus ini service exporter perlu menunggu request tersebut hingga selesai dan cukup memakai data yang sudah diproses dari request sebelumnya.</li><li>Apabila Lock Flag berhasil didapatkan, maka service exporter akan cek apakah ada data yang disimpan dalam cache, jika tidak maka buat lock flag dan lanjut proses untuk mendapatkan data dari database dan memproses data untuk dilanjutkan export excel</li><li>Client B melakukan request di tengah-tengah request dari Client A sedang diproses oleh service exporter</li><li>Client B mengecek bahwa sedang ada Lock Flag yang dipasang oleh request Client A, Client B menunggu hingga data available dari cache</li><li>Service exporter selesai melakukan proses request Client A, menaruh data yang telah diproses dalam cache, menghapus lock flag, dan mengembalikan excel report ke Client A</li><li>Service exporter yang menangani request Client B mendapatkan data dari pemrosesan yang dilakukan dari request Client A dan langsung mengembalikan excel report ke Client B.</li></ol><p>Dengan menggunakan mekanisme locking, kita memastikan bahwa pengambilan data dari database dan pemrosesan data hanya dilakukan satu kali, meskipun ada permintaan yang datang secara bersamaan. Ini menghemat computational cost dan waktu yang diperlukan untuk memproses data yang sama berkali-kali.</p><pre>// proses mendapatkan lock flag<br>local acquired = redis.call(&#39;SET&#39;, lockKey, lockValue, &#39;NX&#39;, &#39;PX&#39;, ttl)<br><br>if acquired then<br>    return 1  -- Lock acquired<br>else<br>    return 0  -- Lock not acquired<br>end</pre><p>Perlu diperhatikan bahwa kita harus memasang TTL untuk Lock Flag yang dipasang pada Redis. Tujuannya adalah untuk menghindari situasi di mana sebuah request yang sedang diproses tiba-tiba terhenti di tengah jalan, sehingga menyebabkan Lock Flag tidak pernah terhapus jika tidak ada TTL. Jika hal ini terjadi, maka request lain akan mengalami deadlock dan tidak akan pernah mendapatkan data.</p><p>Penentuan TTL bisa dilakukan dengan mengukur seberapa lama proses yang dilakukan berjalan, jika sudah mendapatkan waktunya maka itulah yang akan menjadi waktu TTL minimal yang harus dipasang pada lock flag. Hal ini bertujuan agar sebuah lock flag tidak hilang duluan di tengah request sedang menjalankan prosesnya, akibatnya jika lock flag hilang duluan, maka request lain akan mengira tidak ada lock flag dan lanjut untuk memproses hal yang sama.</p><p>Untuk mengatasi multiple Redis instance, diperlukan penanganan yang lebih kompleks. Kita harus memastikan bahwa semua instance memiliki Lock Flag yang sama, dan ketika melepaskan Lock Flag, pastikan bahwa tidak ada satupun instance yang masih memegang Lock Flag tersebut. Penting untuk menghindari situasi di mana beberapa instance memiliki Lock Flag sedangkan yang lain tidak memiliki (partial lock).</p><h4>Kesimpulan</h4><p>Mekanisme locking dalam Redis adalah solusi untuk mengendalikan concurrency dalam sistem, terutama dalam konteks caching dan pengambilan data. Dengan menggunakan mekanisme locking, kita dapat mengoptimalkan caching dan menghindari race condition, sehingga meningkatkan efisiensi dan correctness proses pengambilan data.</p><p>Implementasi mekanisme locking dapat bervariasi tergantung pada kebutuhan dan konteks aplikasi. Redis menyediakan fitur caching dan juga dapat digunakan sebagai penyimpanan Lock Flag untuk mengontrol akses concurrency.</p><p>Dengan menggunakan mekanisme locking, kompleksitas sistem meningkat, tetapi computational cost dan waktu yang dihemat pada proses pengambilan dan pemrosesan data menjadi lebih efisien.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=245b1b735ed9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Abstraction: Simplicity over Complexity]]></title>
            <link>https://rullyafrzl.medium.com/abstraction-simplicity-over-complexity-c3893b6596e9?source=rss-e490a8bef557------2</link>
            <guid isPermaLink="false">https://medium.com/p/c3893b6596e9</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[abstraction]]></category>
            <dc:creator><![CDATA[Rully Afrizal]]></dc:creator>
            <pubDate>Tue, 23 May 2023 04:00:05 GMT</pubDate>
            <atom:updated>2023-05-23T04:00:05.020Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*Ub6Kq18kpmjk21iCJpzZjQ.jpeg" /><figcaption>Van Gogh</figcaption></figure><p>Beberapa waktu lalu saya menemukan sebuah video Youtube yang memantik sesuatu yang sudah saya coba untuk renungkan sejak memasuki dunia Software Engineering. Video yang diupload oleh kanal Youtube <strong>The Royal Institution </strong>yang berjudul “The joy of abstract mathematical thinking” adalah sebuah video lecture yang dibawakan oleh seorang matematikawan bernama Eugenia Cheng. Terms “abstraction” sendiri sangat sering saya temui dalam lecture-lecture atau talks bertemakan Software Engineering. Setelah mengetahui apa arti dari abstraction dalam konteks Software Engineering, kata ini menjadi sangat menarik bagi saya karena kita bisa tarik satu kata ini dan hubungkan ke segala aspek dalam kehidupan era modern yang kita jalani saat ini.</p><blockquote>Pada intinya, abstraction melibatkan satu proses simplifikasi dari suatu sistem yang kompleks dengan berfokus pada satu hal yang penting dan “menutup/menyembunyikan” kompleksitas yang terjadi di belakang layar.</blockquote><p>Segala sesuatu yang sudah tersimplifikasi dan sudah diabstraksikan dari proses yang rumit dibelakangnya biasa disebut dengan high-level abstraction. Sedangkan lawan dari itu adalah low-level abstraction yang artinya adalah implementasi dan detail kecil-kecil yang disembunyikan dari proses simplifikasi tadi. Sebuah tombol yang ada di sepeda motor yang berguna untuk menyalakan sepeda motor atau yang biasa kita kenal sebagai “starter switch” adalah contoh dari high-level abstraction, sedangkan proses pengaliran listrik ketika starter switch ditekan, perputaran crankshaft yang menghasilkan compression dan proses pencampuran bahan bakar di ruang bakar mesin menciptakan pembakaran yang menggerakkan piston dan bagaimana piston tersebut dapat menggerakkan putaran roda penggerak sepeda motor adalah contoh dari low-level abstraction. Dari contoh ini, bisa direnungkan bahwa segala hal modern yang ada di kehidupan sehari-hari adalah bentuk abstraksi dari suatu proses yang kompleks, how mindblowing if you really think about that deeply 🤯</p><p>Di luar ranah software engineering atau engineering lain, abstraction termanifestasi dalam segala aspek. Seorang seniman mengabstraksikan sebuah “emosi” ke dalam sebuah lukisan atau pahatan atau dalam bentuk seni yang lain. Seorang ilmuwan mengabstraksikan “how the world behaves” atau bagaimana cara dunia bekerja dalam sebuah formula matematika yang membuat kita bisa lebih mudah memahaminya. Bahkan dalam komunikasi, kita memiliki rumus atau rule of thumb untuk selalu mensimplifikasikan ide yang akan kita komunikasikan sehingga lawan bicara kita dapat memahami apa yang sedang kita utarakan sehingga menghasilkan komunikasi yang efektif.</p><p>Kalau kita bicara dalam ranah Software Engineering, abstraction sendiri memiliki peran dan dampak yang cukup vital dalam system design, terutama kalau kita mendesain sebuah sistem yang robust, scalable, dan maintainable. Dengan abstraction, kita bisa berfokus pada implementasi secara high-level dan melupakan hal-hal manual yang terjadi di balik layar untuk sementara, kita bisa berfokus pada struktur business logic yang kita ingin buat dan tidak perlu khawatir dan peduli bagaimana aplikasi kita bisa berjalan. Dengan ini terciptalah banyak abstraksi seperti bahasa pemrograman, framework, library, tools, dan lain sebagainya yang pada intinya hanyalah sebuah simplifikasi dari proses kompleks dibelakangnya. Bayangkan bagaimana abstraksi merevolusi Software Engineering dalam kurun waktu 30 sampai 40 tahun terakhir, seorang computer scientist pada masa itu harus mempunyai pemahaman yang cukup dalam mengenai kernel, compiler, core operating system, memory management, assembly. Bahasa pemrograman pada kala itu sangat dekat dengan hardware level dan seorang programmer harus berurusan dengan hardware component meski yang akan mereka bangun adalah sebuah software.</p><p>Melihat perjalanan ke depan, sangat mungkin abstraction yang lebih dalam dan lebih jauh akan terus berlanjut. Sebagaimana arus perkembangan teknologi berjalan, kita bisa berekspektasi atau berharap akan ada lebih banyak otomasi, piranti cerdas yang mengeliminasi proses manual dan repetitif yang masih kita lakukan sekarang. Sebuah kecerdasan buatan (AI) yang sedang naik daun di tahun artikel ini ditulis juga salah satu bentuk abstraksi dari hal kompleks dibelakangnya seperti image recognition, natural languang processing (NLP), dan data analysis.</p><p>Cukup menjadi catatan penting bahwa meskipun abstraction membawa simplifikasi dari proses yang rumit, hal ini membuka tantangan baru. Semakin sebuah sistem ter-abstraksikan dari proses kompleksnya, semakin kita sebagai pengguna kehilangan knowledge atau pengetahuan how the underlying things work. Berapa banyak seorang web developer di era ini yang sama sekali tidak mengerti bagaimana low level sistem bekerja akan tetapi mereka masih tetap bisa membuat sebuah web yang sangat keren.</p><p>Pengetahuan mendalam akan underlying concept bisa berguna pada kasus tertentu seperti performance optimization, troubleshooting, atau ketika kita ingin membuat sesuatu from scratch. Dan pada akhirnya, pengetahuan mendalam akan underlying concept dari suatu proses juga masih sangat penting apabila kita ingin mencapai grandiosity dan tidak ingin terjebak dalam perangkap mediocrity sebagai seorang engineer. Menari ditengah dua unsur itu menjadi sangat indah, mencari titik seimbang antara abstraction dan pemahaman konsep dasar masih akan menjadi satu hal yang penting untuk menjadi seorang engineer yang handal.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c3893b6596e9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unit Test 101]]></title>
            <link>https://rullyafrzl.medium.com/unit-test-101-c7972d55170b?source=rss-e490a8bef557------2</link>
            <guid isPermaLink="false">https://medium.com/p/c7972d55170b</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Rully Afrizal]]></dc:creator>
            <pubDate>Sat, 17 Dec 2022 09:43:09 GMT</pubDate>
            <atom:updated>2022-12-17T09:49:29.859Z</atom:updated>
            <content:encoded><![CDATA[<p>Unit test, mendengar namanya sepertinya cukup familiar terutama jika anda seorang software engineer. Betul, satu metode yang sudah tidak rahasia lagi paling malas dilakukan oleh kebanyakan engineer, salah satu alasannya adalah karena mereka pikir bahwa menulis unit test hanya akan membuang-buang waktu. Selama metode manual test yang mereka lakukan berhasil, mengapa kita menghabiskan waktu lagi untuk menulis kode hanya untuk melakukan tugas yang cukup dengan manual testing. Artikel kali ini akan membahas secara singkat dasar pengetahuan tentang unit test, beberapa fakta dan miskonsepsi tentang unit test. Mari kita bahas definisi unit test untuk memulai.</p><h3>Unit Test</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/420/1*URgmQ8YcoLWovbIoMI_Wyw.jpeg" /><figcaption><a href="https://semaphoreci.com/blog/testing-pyramid">https://semaphoreci.com/blog/testing-pyramid</a></figcaption></figure><p>Unit testing adalah metode pengujian yang dibangun di atas ide untuk menguji program dengan memecah fungsionalitas dari program yang kita bangun menjadi fungsionalitas yang lebih kecil dan bisa diuji sebagai unit individual. Kata kunci yang perlu diperhatikan di sini adalah unit individual. Ketika kita melakukan unit test, yang harus diperhatikan adalah kita benar-benar melakukan satu pengujian hanya untuk satu unit.</p><p>Secara sederhana, pengertian istilah unit sendiri dalam unit test yaitu adalah suatu komponen yang dipecah menjadi independen terhadap komponen lainnya. Dalam paradigma Object-Oriented unit bisa diartikan sebagai class, sedangkan pada paradigma Functional Programming unit diartikan sebagai function. Tetapi perlu diperhatikan bahwa pengertian unit ini masih bisa diinterpretasikan terhadap sesuatu yang berbeda, tergantung situasinya, jadi jangan selalu tergantung pada definisi yang saya paparkan.</p><h3>Manfaat Unit Test</h3><p>Salah satu miskonsepsi atau mitos yang sering didengar adalah penulisan unit test memakan waktu yang cukup lama, bahkan bisa sampai dua kali waktu development unit. Faktanya, menurut penelitian dari Microsoft, durasi waktu yang dihabiskan untuk menulis unit test hanya berkisar sekitar 20% dari keseluruhan development. 20% waktu tambahan ini bisa berdampak pada berkurangnya defect yang muncul ketika pengujian oleh QA sebesar 20,9%, selain itu juga mengurangi waktu yang dihabiskan kedepannya untuk fixing bug yang muncul di masa depan.</p><blockquote><a href="https://collaboration.csc.ncsu.edu/laurie/Papers/Unit_testing_cameraReady.pdf">https://collaboration.csc.ncsu.edu/laurie/Papers/Unit_testing_cameraReady.pdf</a></blockquote><p>Dengan menulis unit test, menurut penelitian Microsoft kita sebagai engineer juga akan merasa lebih percaya diri untuk deliver code kita kepada QA dengan skor 80–90%. Hal ini akan berdampak pada kecepatan kita dalam deliver code. Kualitas yang dihasilkan juga akan meningkat secara pesat dengan menerapkan unit test dan dokumentasi baik dan benar.</p><h3>Unit Test Best Practice</h3><h4><strong>Jelas dan Detail</strong></h4><p>Unit test harus ditulis dengan sangat jelas dan detail, dengan ini kita secara otomatis bisa membuat dokumentasi tentang behavior dari unit yang sedang kita uji. Untuk memulai menulis unit test yang jelas dan detail bisa dimulai dari nama function tiap test. Template yang biasa saya gunakan adalah <strong><em>behaviorUnit_kondisiDanFaktor_ekspektasiHasil</em></strong>. Selain itu, usahakan untuk selalu menulis kode pengujian dengan rapi, bisa dimulai dengan nama variabel yang singkat namun deskriptif. Contoh bagaimana unit test yang selalu saya tekankan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FXHxYzt8aU3ydR8MHkURYw.png" /></figure><h4><strong>Full Coverage</strong></h4><p>Ketika menulis unit test, usahakan untuk selalu mengcover semua kemungkinan yang akan terjadi pada business logic. Semua conditional yang ada pada unit harus diusahakan masuk pada unit test, hal ini bisa dilakukan dengan membuat beberapa unit test untuk masing-masing kasus yang masuk dalam cabang conditional. Beberapa framework testing memiliki fitur untuk mengukur coverage dari unit test yang kita buat, pastikan kita mengutilisasi fitur itu dengan maksimal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*taD_L_FDwf7Lq419z3KvoA.png" /></figure><h4><strong>Unit Terisolasi</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aj-Z34cBE-mDgzb5116ykg.png" /><figcaption><a href="https://martinfowler.com/bliki/images/unitTest/isolate.png"><strong>https://martinfowler.com/bliki/images/unitTest/isolate.png</strong></a></figcaption></figure><p>Hal ini sebenarnya masih terjadi perdebatan, sesuai gambar di atas, ada dua jenis metode yang bisa dilakukan</p><ol><li><strong>Sociable test,</strong> yaitu metode untuk tetap memanggil dependency dari sebuah unit yang akan diuji secara real. Belakangan ini, metode ini sudah jarang digunakan karena sifatnya yang non-deterministik. Sebagai engineer, kita bisa saja ada dalam situasi di mana kita tidak tahu kapan dependency yang dipanggil secara real akan gagal atau berhasil. Contohnya ketika behavior sebuah unit ingin mengambil data dengan cara outbound call ke service lain, kita tidak tahu kapan akan terjadi network failure dan sebagainya. Hal ini akan menyulitkan kita untuk menguji unit secara full coverage.</li><li><strong>Solitary Test, </strong>yaitu metode untuk mengisolasi unit yang kita uji dengan dependency yang akan dipanggil. Metode isolasi ini bisa dilakukan dengan cara populer yang dinamakan “mocking”. Dengan menggunakan metode ini, kita bisa menentukan hasil yang akan dikembalikan oleh dependency lain, sehingga kita bisa mengcover semua conditional pada business logic unit secara deterministik. Contoh bisa dilihat pada gambar sebelumnya, di pengujian itu saya mock hasil dari <strong><em>customerDao</em></strong>. Saya bisa atur dan tentukan <strong><em>customerDao</em></strong> untuk mengembalikan objek <strong><em>Customer</em></strong> ataupun malah mengembalikan error not found.</li></ol><p>Saya sendiri beranggapan bahwa untuk melakukan unit test, metode terbaik adalah dengan menggunakan Solitary Test. Dengan menggunakan metode ini, istilah dari unit test sendiri sejajar. Apabila kita menggunakan Sociable Test, yang kita lakukan justru keluar dari ranah unit test dan malah masuk ke dalam Integration Test karena menghadirkan panggilan secara real kepada beberapa dependency lain. Sifat dari sociable yang non-deterministik juga tidak bisa diprediksi, bayangkan ketika kita ingin deliver program kita malah mendapati unit test kita kadang error dan kadang juga berhasil, hal ini akan menghambat delivery time menjadi lebih lama.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c7972d55170b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Java Boros Memory?]]></title>
            <link>https://rullyafrzl.medium.com/java-boros-memory-29556126b4cb?source=rss-e490a8bef557------2</link>
            <guid isPermaLink="false">https://medium.com/p/29556126b4cb</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[reactive]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[threads]]></category>
            <dc:creator><![CDATA[Rully Afrizal]]></dc:creator>
            <pubDate>Thu, 15 Dec 2022 08:02:24 GMT</pubDate>
            <atom:updated>2022-12-15T08:02:24.417Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*op6N_h88DofxbC7E" /></figure><p>“Java butuh resource memory gede, mending kita pake yang lain aja”, begitulah kata mereka. Dengan pesatnya perkembangan teknologi dari sisi bahasa pemrograman, para Software Engineer tentu saja memiliki pilihan dan alternatif lain yang pas dan cocok untuk menjadi pondasi atas sistem yang akan mereka bangun. Seorang engineer yang bekerja di perusahaan, tentu saja akan memilih pondasi yang paling efisien agar bisa menekan biaya yang dikeluarkan untuk maintain resource dari sistem yang mereka bangun. Dalam hal ini, Java selalu dihindari oleh sebagian besar perusahaan kecil atau startup menengah karena borosnya memory usage yang mereka pakai, mereka cenderung untuk beralih ke pondasi lain seperti NodeJS, PHP, atau Go. Kalau kita beralih ke perusahaan dengan skala lebih besar, penggunaan Java masih sangat banyak terutama di perbankan dengan skala sistem yang cukup masif.</p><p>Pada artikel kali ini, saya ingin mengulik tentang Java, bagaimana Java bekerja dibalik layar dalam menangani request yang masuk, mengapa Java masih dipakai di perusahaan besar walaupun sudah terkenal sebagai bahasa pemrograman yang dianggap usang dan makan memory usage yang cukup besar, dan apakah utilisasi memory yang cukup besar di Java ini baik untuk sistem yang kita bangun atau tidak.</p><p>Java</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/0*e5albbRLG8zoTzzE" /><figcaption><a href="https://www.geeksforgeeks.org/compilation-execution-java-program/">https://www.geeksforgeeks.org/compilation-execution-java-program/</a></figcaption></figure><p>Java pada dasarnya adalah bahasa pemrograman compiled dan interpreted secara bersamaan. Apabila bahasa pemrograman lain adalah compiled saja atau interpreted saja, maka Java adalah keduanya. Mengapa demikian? Kalau kita lihat dari build process di bahasa pemrograman lain yang compiled, prosesnya adalah compiler menerjemahkan bahasa pemrograman tersebut ke bahasa mesin yang spesifik, setelah itu mesin tersebut akan menjalankan terjemahan tadi. Berbeda dengan Java, di Java sendiri memiliki compiler yang dinamakan Java Compiler atau biasa disebut javac. Java Compiler ini tidak langsung menerjemahkan kode Java ke bahasa mesin yang spesifik, melainkan di-compile dulu ke bytecode yang menghasilkan file .jar atau .class, file ini nantinya akan dijalankan oleh Virtual Machine buatan Java sendiri yang dinamakan Java Virtual Machine (JVM). Proses yang dilakukan oleh JVM itulah dimana Java di-interpret. Jadi urutannya adalah Java Compiler mengubah ke bytecode menjadi file .jar (compile), kemudian file .jar dijalankan oleh JVM (interpret).</p><h4>Java Dalam Menangani Request</h4><p>Ketika kita membuat aplikasi Java, terutama kini yang paling populer adalah dengan menggunakan Spring Ecosystem, kita dihadapkan dengan dua pilihan.</p><ol><li>Servlet, ini adalah base aplikasi paling umum dan tradisional, servlet ini masih menggunakan prinsip blocking atau synchronous dalam menangani request yang masuk.</li><li>Reactive, ini adalah base aplikasi yang saat ini sedang naik daun, reactive ini menggunakan prinsip non-blocking atau asynchronous dalam menangani request yang masuk.</li></ol><p>Adakah perbedaan antara keduanya? apakah reactive lebih baik dan cepat ketika digunakan ketimbang menggunakan tradisional servlet? Sebelum itu, mari kita bahas bagaimana masing-masing dari keduanya menangani request yang masuk.</p><h4>Servlet</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sdEV2I77vf7zvOwc" /><figcaption><a href="https://singhkaushal.medium.com/spring-webflux-eventloop-vs-thread-per-request-model-a42d07ee8502">https://singhkaushal.medium.com/spring-webflux-eventloop-vs-thread-per-request-model-a42d07ee8502</a></figcaption></figure><p>Dalam kasus servlet, apabila aplikasi kita menerima request dari luar, hal yang pertama kali terjadi adalah servlet menyediakan request dan response object. Request yang diwakili oleh objek HttpServletRequest digunakan untuk menyediakan akses ke data request yang datang. Di sisi lain, Response yang diwakili oleh HttpServletResponse digunakan untuk menyediakan akses ke data response yang akan dikembalikan ke client. Setiap per request yang masuk, servlet sendiri melalui container-nya akan membuat dan menugaskan satu Thread baru untuk mengeksekusi handler sesuai request yang masuk. Thread tersebut akan terdedikasi untuk satu request saja, dan tidak akan mengeksekusi perintah dari request lain. Sekarang apabila terdapat 100 request yang masuk ke aplikasi kita, maka servlet akan membuat 100 Thread dan menugaskan Thread-thread tersebut ke masing-masing request.</p><p>Salah satu container servlet yang paling terkenal adalah Apache Tomcat, biasanya Apache Tomcat sendiri sudah di-bundle ke dalam framework yang kita pakai seperti contohnya Spring Boot. Pada Tomcat yang ada di Spring Boot, terdapat konfigurasi default maksimum Thread yang dapat dibuat oleh aplikasi kita. Biasanya konfigurasi tersebut berada di angka 200. Apa artinya? Jadi, jika terdapat request melebihi angka 200, katakanlah 210 request masuk ke dalam aplikasi kita, maka 10 request terakhir akan menunggu untuk Thread lain selesai dalam mengeksekusi programnya, begitu selesai 10 request tadi akan dieksekusi oleh Thread yang selesai duluan satu persatu. Apabila semua request sudah selesai, Thread yang selesai melakukan tugasnya akan kembali ke dalam kolam yang namanya adalah Thread Pool, di sana ia tidak langsung dihapus, melainkan menunggu request baru masuk sampai batas waktu yang telah ditentukan. Apabila sampai batas waktu tidak ada request yang masuk, maka Thread tersebut akan dihapus dari Thread Pool.</p><p>Pada setiap Thread yang telah dibuat ketika sebuah request masuk, maka ada alokasi memori yang diperlukan untuk masing-masing Thread karena Thread sendiri adalah objek yang memakan memori. Ukuran masing-masing Thread ini bervariasi tetapi pada umumnya berukuran kurang lebih 1 MB. Jadi dengan menggunakan patokan itu, kita bisa hitung apabila ada 1000 request yang masuk pada aplikasi kita, maka aplikasi kita setidaknya harus mengalokasikan 1 GB memory yang digunakan untuk menghandle eksekusi dari request yang masuk.</p><p>Java Servlet ini sangat cocok digunakan pada kasus aplikasi yang memiliki kecenderungan berat di bagian computing, atau yang dinamakan CPU bound. Mengapa demikian? Karena setiap dari Thread yang dibuat akan benar-benar terpakai tanpa harus menunggu data, karena di setiap baris kode Thread yang mengeksekusinya benar-benar terus menerus bekerja.</p><h4>Reactive</h4><p>Dengan semakin banyaknya penggunaan internet, maka diharapkan user dari aplikasi kita akan semakin banyak. Hal ini tentu saja akan terus mendorong perkembangan teknologi untuk dapat menyelesaikan masalah apapun. Permintaan untuk scaling aplikasi akan terus ada selama pasarnya semakin berkembang, dan tentu saja biaya harus bisa ditekan sekecil mungkin. Kalau menggunakan pendekatan blocking dari servlet, banyaknya request akan berbanding lurus dengan resource yang dibutuhkan. Hal ini tentu saja kurang efisien, apalagi banyak dari aplikasi kita yang tidak terlalu berat di computing, tetapi hanya sebatas input dan output data saja, hal ini akan membuat Thread yang kita buat akan nganggur ketika menunggu data diambil dari database, atau dari service lain. Intinya adalah servlet kurang efisien apabila digunakan pada aplikasi yang sering melakukan network call atau input output.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pLIh6KsRbXg_6ct7" /><figcaption><a href="https://singhkaushal.medium.com/spring-webflux-eventloop-vs-thread-per-request-model-a42d07ee8502">https://singhkaushal.medium.com/spring-webflux-eventloop-vs-thread-per-request-model-a42d07ee8502</a></figcaption></figure><p>Salah satu implementasi dari non-blocking di java sendiri untuk menangani network call adalah Java Netty. Dengan menggunakan non-blocking dari Netty ini sendiri, Thread yang kita buat tidak perlu menunggu selagi melakukan network call, dalam periode waktu itu, Thread bisa ditugaskan untuk melakukan eksekusi program lainnya. Hal ini tentu saja akan mengurangi jumlah Thread yang harus ada untuk menangani banyak request.</p><p>Netty sendiri pada tingkatan low-level menggunakan Event Loop untuk manajemen Thread, mirip seperti yang dilakukan oleh NodeJS. Jumlah Thread default yang ada pada netty adalah 2 x Jumlah Core pada CPU, artinya semua request yang masuk, berapapun jumlahnya, akan dieksekusi oleh Thread itu saja, sehingga jauh lebih hemat dan tidak perlu membuat Thread per request seperti di servlet. Salah satu referensi yang bagus untuk mengetahui bagaimana Event Loop di Netty bekerja, bisa dibaca lewat blog ini <a href="https://www.alibabacloud.com/blog/essential-technologies-for-java-developers-io-and-netty_597367">https://www.alibabacloud.com/blog/essential-technologies-for-java-developers-io-and-netty_597367</a></p><h4>Utilisasi Memory</h4><p>Seperti yang saya bilang sebelumnya, kebutuhan untuk mengembangkan aplikasi berbasis input output akan cenderung lebih tinggi daripada basis komputasi berat. Kebutuhan akan data menjadi semakin tinggi, “<em>Data is the new gold</em>”. Ketika dihadapkan dengan kasus ini, tentu saja penggunaan reactive akan lebih bagus dan efisien untuk resource hardware ketimbang menggunakan servlet. Objektif kita adalah untuk membuat sistem yang memiliki reliabilitas yang tinggi dalam menjawab kebutuhan user. Ketika membuat aplikasi, tentunya data tersebut bisa kita dapatkan dari berbagai sumber. Beberapa sumber dari data yaitu seperti file, network, dan memory. Network adalah ketika kita mengambil data dari database, atau ketika kita kirim request ke service lain. Network adalah sumber data yang paling lambat, sehingga ketika kita membuat aplikasi, kita harus mempunyai prinsip untuk mengurangi network call sebanyak mungkin. Bagaimana caranya?</p><p>Disinilah utilisasi memory itu bekerja, penyebab dari ketakutan orang terhadap Java yang terkenal sebagai pemakan memory. Ketika kita ingin mengurangi network call sebanyak mungkin, artinya kita ingin simpan data tersebut ke dalam memori. Faktanya, memory adalah sumber data yang paling cepat untuk diakses di antara ketiga sumber data. Menyimpan data yang telah kita ambil dari network call ke dalam memory, metode inilah yang biasa disebut sebagai caching. Tujuan dari caching hanyalah untuk mengurangi network call yang cukup mahal harganya dan tentu saja lambat. Caching inilah yang menjadi penyebab memory usage dari aplikasi kita menjadi tinggi. Kalau penyebab memory usage tinggi karena caching, sebenarnya ini tidak bisa dikatakan buruk, karena kita mengutilisasi keseluruhan resource yang disediakan. Bayangkan ketika kita membeli VM dengan spesifikasi RAM 8 GB tetapi yang terpakai hanya 2GB saja, hal ini tentu saja tidak efisien. Kalau bisa memakai keseluruhan 8GB tadi dengan mengutilisasi memori, kita pakai saja, efeknya tentu saja aplikasi kita akan menjadi lebih cepat.</p><h4>Terakhir</h4><p>Aplikasi yang memakan memori belum tentu buruk. Semua tergantung dari aplikasi apa yang kita buat. Rule of thumb yang seharusnya diikuti adalah apabila kita membuat aplikasi yang berat di I/O atau input output, maka ketika request yang masuk banyak, dan kita mengutilisasi memori dengan baik, maka resource yang usage-nya naik memang seharusnya adalah memory. Apabila CPU yang naik drastis, maka di sini baru ada kesalahan yang harus diperbaiki.</p><p>Banyak perusahaan besar yang masih memakai Java adalah karena sampai saat ini Java masih relevan dan bisa menjawab kebanyakan problem yang ingin diselesaikan oleh perusahaan-perusahaan tersebut. Performanya yang masih di atas NodeJS, PHP, Ruby, dan sebagainya masih menjadi pilihan. Selain itu Java sudah sangat mature dan robust, serta didukung oleh komunitas yang sangat banyak. Hal ini membuat Java bagus untuk investasi jangka panjang, mendukung pengembangan sistem besar jangka panjang. Itulah alasan mengapa Java masih diminati, lalu mengapa startup kecil-menengah tidak mengikuti jejak big company? Jawabannya adalah karena learning path dari Java sendiri sangat banyak, seorang engineer tidak akan selesai belajar Java hanya dalam waktu 1 atau 2 bulan. Selain itu, development dari Java sendiri butuh level yang lebih senior karena memang Java ini cukup sulit untuk dipahami di level Junior Engineer. Berbeda dengan PHP yang kini memiliki Laravel, atau Javascript yang kini memiliki NodeJS. Di masa growing yang sangat cepat ini, banyak perusahaan yang cenderung untuk memilih pondasi yang bisa deliver aplikasi dengan cepat, maka dari itu Java lebih populer kepada perusahaan besar yang berinvestasi pada teknologi secara jangka panjang dan memiliki banyak engineer yang lebih senior.</p><p>Begitulah pembahasan saya mengenai Java yang cukup singkat ini, semoga dapat menyalurkan sedikit tambahan ilmu mengenai Java kepada pembaca, terimakasih.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=29556126b4cb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Event-Driven Architecture, Solusi Decoupling Microservice]]></title>
            <link>https://rullyafrzl.medium.com/event-driven-architecture-solusi-decoupling-microservice-8f1c8d675739?source=rss-e490a8bef557------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f1c8d675739</guid>
            <category><![CDATA[event-driven-architecture]]></category>
            <category><![CDATA[rabbitmq]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[system-design-concepts]]></category>
            <category><![CDATA[message-broker]]></category>
            <dc:creator><![CDATA[Rully Afrizal]]></dc:creator>
            <pubDate>Tue, 13 Dec 2022 10:20:15 GMT</pubDate>
            <atom:updated>2022-12-13T10:20:15.042Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lh2apvrqUle0A21ISvPAng.png" /></figure><p>Arsitektur Event-Driven yang kini menjadi populer karena dapat menyelesaikan masalah yang terdapat dalam penerapan microservice yang juga sedang gencarnya diadopsi oleh banyak perusahaan teknologi. Sebelum kita membahas lebih jauh terkait arsitektur Event-Driven, saya akan menjelaskan tentang latar belakang microservice, dan beberapa masalah yang bisa kita jawab dengan menggunakan arsitektur Event-Driven.</p><h4>Microservice</h4><p>Microservice, sebuah arsitektur yang dibangun di atas ide untuk memecah satu aplikasi monolithic besar menjadi aplikasi-aplikasi kecil yang saling terintegrasi satu sama lain namun independen, yang artinya adalah meski saling terhubung, satu service dengan service lainnya dapat kita jalankan, dan kita deliver dengan sendiri-sendiri tanpa memiliki dependensi satu sama lain. Hingga saat ini, sudah banyak perusahaan teknologi raksasa yang menjadi pelopor penggunaan microservice, sehingga perusahaan kecil atau startup yang menyelesaikan problemnya dengan teknologi juga mulai mengadopsi arsitektur microservice.</p><p>Pada dasarnya, ketika sebuah perusahaan ingin membuat aplikasi untuk pertama kali, mereka akan mulai membangun sistemnya dengan mengadopsi monolithic architecture, yaitu satu aplikasi besar yang melayani semua kebutuhan, hal ini tentu saja adalah kebalikan dari microservice. Ketika sistem monolithic yang dibangung ini menjadi semakin besar skalanya, akan timbul masalah-masalah tertentu. Secara ringkas masalah yang sering ditemui apabila sistem monolith telah terlampau besar yaitu:</p><ul><li>Menjalankan service monolith di lokal akan sangat berat dan membutuhkan resource yang tinggi, hal ini otomatis berdampak pada produktivitas engineer</li><li>Scaling harus dilakukan terhadap keseluruhan sistem, tidak bisa bagian tertentu saja atau fitur tertentu</li><li>Sulit untuk mengganti tech stack, karena implementasi tech stack tersebut sudah terlalu besar dan akan sulit untuk refactor</li><li>New joiner engineer akan terintimidasi dengan besarnya sistem yang harus ia kuasai</li></ul><p>Masalah-masalah inilah yang ingin kita selesaikan dengan cara mengadopsi microservice architecture dalam sistem yang kita bangun. Lalu apa hubungan semua ini dengan arsitektur Event-Driven? Mari kita bahas.</p><h4>Pola Komunikasi Antar Service</h4><p>Pada arsitektur microservice, setiap service saling terintegrasi sehingga dibutuhkan pola komunikasi yang reliable. Secara garis besar ada dua pola komunikasi yang digunakan dalam arsitektur microservice, mari kita anggap pola komunikasi adalah client-server, dimana server adalah service penyedia dan client adalah service yang meminta.</p><ol><li>Sync, dimana client akan menunggu hingga server menyediakan response</li><li>Async, client tidak akan menunggu dan akan menjalankan tugas lain selagi server menyediakan response</li></ol><p>Pada umumnya, synchronous adalah pola komunikasi yang paling populer karena kemudahannya dalam implementasi, contoh dari komunikasi synchronous adalah mekanisme berbasis HTTP seperti REST API dan gRPC. Contoh penggunaannya ketika client ingin data user pada service member, maka kita tinggal kirim HTTP request API dan menunggu untuk menerima hasil balikan atau respons yang diberikan oleh service member.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/481/1*SVDG7YVFsoAcSEYWaiGLyA.png" /></figure><p>Dalam kasus ini, penggunaan pola komunikasi synchronous cukup tepat karena order service membutuhkan data user dari member service untuk digunakan dalam business logic selanjutnya. Apabila member service tidak mengirim balik data user yang diinginkan, maka proses apapun itu yang dilakukan selanjutnya oleh order service tidak akan bisa lanjut, dalam hal ini penting sekali bagi order service untuk menunggu dan mendapatkan data dari member service. Dengan begini, hubungan antar dua service tersebut adalah tightly coupled, yang artinya sangat membutuhkan antara satu sama lain. Kedua service tersebut harus tetap reliable setiap saat untuk memastikan proses bisnis akan berjalan dengan normal.</p><p>Akan tetapi, ada kasus tertentu dimana ciri khas dari pola komunikasi synchronous ini yaitu membuat hubungan antara service ini menjadi coupled menyebabkan berbagai masalah, singkatnya pola komunikasi ini tidak bisa diterapkan pada berbagai komunikasi antar service. Dalam suatu kasus, ketika end user ingin login ke dalam aplikasi kita, kita ingin secara otomatis aktivitas login dari user kita simpan ke dalam database untuk keperluan logging. Contoh ketika komunikasi antar service terjadi secara synchronous adalah seperti ini.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WNsN72Hyj9Y9i6FaU1Jjtg.png" /></figure><p>Dengan menggunakan pola ini, kita akan menjadikan auth service dan log service menjadi coupled dan pastinya kedua service itu harus reliable ketika user sedang login. Apa jadinya ketika log service mati dan user sedang login? tentu saja log service tidak akan mampu untuk menyimpan aktivitas user ke dalam database, dan auth service akan mendapat response error unavailable service. Sekarang apabila kita tidak menyediakan error handler pada auth service, tentu saja user tidak akan bisa login hanya karena sistem kita untuk menyimpan aktivitas user sedang tidak reliable. Walaupun kita menyiapkan error handler, tetap saja aktivitas login dari user tersebut tidak bisa dicatat dan akan terbuang datanya. Dalam hal ini kita bisa terapkan arsitektur Event-Driven sebagai solusi.</p><h4>Event-Driven Architecture</h4><p>Event-Driven architecture adalah sebuah arsitektur pola komunikasi yang memungkinkan dua service berhubungan dengan cara asynchronous. Arsitektur ini dibangun atas ide untuk memecah ketergantungan atau coupled antar microservice, dengan cara mendeteksi sebuah event yang umumnya dikirim via message broker, sehingga service yang membutuhkan bisa bereaksi terhadap event tersebut dan lanjut melakukan tugasnya. Dalam hal ini, service yang mengirim sebuah event tidak peduli dan tidak menunggu hasil dari service yang bereaksi terhadap event tersebut. Event-Driven juga biasa disebut sebagai Message-Based communication.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2bZj33FImc3nFE2PR0jsZw.png" /></figure><p>Dalam kasus tadi, kita pisahkan hubungan langsung atau direct call antara auth dan log service dengan menggunakan message broker di tengahnya. Ketika user login, auth service akan men-publish message ke message broker, data aktivitas user tersebut akan disimpan dalam queue atau antrian di message broker yang untuk kemudian akan dikonsumsi oleh log service. Secara otomatis, apabila pada suatu waktu log service mati, maka data aktivitas user akan tetap berada di message broker, sampai pada saatnya log service nyala kembali dan mengonsumsi data aktivitas dari message broker.</p><blockquote>Saat ini sudah banyak message broker yang bisa kita gunakan dan sudah diadopsi oleh banyak perusahaan karena reliabilitasnya yang tinggi seperti Apache Kafka, RabbitMQ, NSQ, Redis PubSub, Google PubSub.</blockquote><p>Dalam kasus lain, kita bahkan dapat mengirim sebuah data ke beberapa service dalam satu kali publish ke message broker, hal ini akan lebih mempermudah implementasi karena kita tidak perlu membuat direct call ke masing-masing service. Seperti contoh ini, auth service bahkan tidak tahu service mana saja yang akan mengonsumsi data yang dia kirim ke message broker, begitu data terkirim ke message broker, semua service yang membutuhkan bisa consume data tersebut dan dipergunakan sesuai bisnis prosesnya masing-masing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AMBawfk5-l5yzCxPMhKYEQ.png" /></figure><h4>Penutup</h4><p>Demikianlah pembahasan singkat terkait dengan Event-Driven architecture, mungkin sekarang timbul pertanyaan, bukannya penerapan dari message-based dengan menggunakan message broker ini malah menimbulkan dependent antara auth service dan message broker? Lantas mengapa kita berbicara soal decoupling antar service kalau solusi dengan message broker ini juga tetap menimbulkan coupling antara service dengan message broker? Jawabannya adalah karena komunikasi dengan message broker masih lebih baik dibandingkan dengan direct call menggunakan HTTP, reliability dari message broker itu sendiri sudah dikenal tangguh sehingga opsi ini tetap menjadi pilihan. Dan selain itu, selama di antara service ini membutuhkan integrasi, maka tidak ada yang namanya 100% decoupled system, service-service tersebut masih akan terkait satu sama lain apapun penghubungnya, dan ini tugas kita sebagai engineer untuk selalu memastikan penghubung tersebut memiliki reliabilitas yang tinggi untuk menunjang bisnis proses.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f1c8d675739" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Netflix Hystrix, Solusi Resiliensi dalam Prinsip Reactive System]]></title>
            <link>https://rullyafrzl.medium.com/netflix-hystrix-solusi-resiliensi-dalam-prinsip-reactive-system-f2843def9956?source=rss-e490a8bef557------2</link>
            <guid isPermaLink="false">https://medium.com/p/f2843def9956</guid>
            <category><![CDATA[hystrix]]></category>
            <category><![CDATA[circuit-breaker]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-design-patterns]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Rully Afrizal]]></dc:creator>
            <pubDate>Thu, 03 Nov 2022 12:59:45 GMT</pubDate>
            <atom:updated>2022-11-03T12:59:45.850Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FUjVP69My3dO-1EK1P4p4w.png" /></figure><p>Kebutuhan dalam membuat software menjadi semakin kompleks belakangan ini. Sekitar sepuluh tahun lalu, mengambil peran development hingga deployment aplikasi bagi seorang software engineer hanya sesimpel menyiapkan VM server bare-metal, setup satu server yang berperan sebagai backend maupun frontend. Bahkan di jaman itu mungkin masih belum populer istilah backend atau frontend. Semuanya dilakukan oleh Software Engineer yang memiliki peran dari membuat desain hingga mengirim aplikasi ke server untuk bisa diakses melalui internet.</p><p>Saat ini seperti yang kalian tahu, dengan semakin meningkatnya kebutuhan akan akses internet maka semakin banyak orang yang menggunakan solusi digital yang diciptakan oleh para pengusaha dan diimplementasikan oleh kita para engineer, maka kita mau tidak mau harus membangun dan merancang sistem yang bisa bekerja dengan lancar untuk bisa menghandle ribuan, ratusan ribu, bahkan jutaan concurrent user dalam waktu bersamaan. Pada awalnya solusi scaling hanya sebatas membeli server baru yang lebih besar, menambah core, RAM, dan lain sebagainya. Itu semua hanyalah solusi jangka pendek yang sangat mahal dan kurang efisien.</p><p>Sekarang semua software dalam skala besar harus dibangun dengan lebih kompleks. Banyak dari software skala besar berjalan di atas cloud-based server dengan menggunakan ratusan bahkan ribuan Kubernetes Cluster dengan spesifikasi hardware yang sangat tinggi. Kebutuhan akan reliability sebuah sistem menjadi prioritas. Kebutuhan-kebutuhan ini mendesak kita memikirkan cara untuk mengadopsi strategi dan teknologi yang lebih baru. Salah satunya adalah arsitektur microservice, yang artinya adalah suatu arsitektur sistem yang memecah satu service monolith besar menjadi service-service yang lebih kecil. Dengan munculnya strategi baru ini pastinya masalah-masalah baru juga akan muncul, terutama terkait resiliensi.</p><p>Kalau pernah belajar tentang Reactive System, pasti akan mengenal salah satu pilarnya yaitu resiliensi. Singkatnya, Reactive System adalah gabungan dari 4 prinsip yang sangat direkomendasikan untuk dijadikan panduan ketika kita membuat sistem microservice skala besar. Saya tidak akan bahas detail mengenai Reactive System, silahkan bisa anda baca sendiri di https://www.reactivemanifesto.org/ .</p><h4><strong>Masalah Resiliensi Arsitektur Microservice</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/539/1*ACUmDJMHKO-_YI-JuHJWOg.png" /><figcaption><a href="https://microservices.io/patterns/microservices.html">https://microservices.io/patterns/microservices.html</a></figcaption></figure><p>Dalam sebuah kasus, kita memiliki satu aplikasi e-commerce yang berjalan di atas beberapa microservice. Ketika kita ingin mengecek progress pengiriman dari barang yang kita pesan dengan fitur lacak pengiriman. Di balik layar kita ibaratkan Order service memanggil (outbound) ke service third party dari penyedia jasa pengiriman dengan parameter nomor resi untuk mendapatkan data progress pengiriman barang. Dengan approach ini, maka kita bisa dihadapkan dengan beberapa kemungkinan failure yang bisa saja terjadi.</p><ol><li><strong>Immediate Failure:</strong> yaitu failure yang terjadi secara langsung. Contohnya ketika service dari third party kita down, atau connection refused karena suatu masalah. Meskipun kita pasang exception catch dan retry dengan exponential backoff di kasus ini, tetap saja jika service masih down maka akan tetap mengembalikan response error yang sama. Jadi untuk apa kita terus-terusan memanggil service third party jika kita tahu hasilnya akan gagal terus menerus.</li><li><strong>Timeout Failure:</strong> yaitu failure yang terjadi karena lambatnya respon yang dikirim dari sebuah proses diukur dari waktu timeout yang sudah dikonfigurasi. Contohnya ketika banyak sekali client yang berusaha memanggil service third party tersebut, sehingga thread yang ditugaskan untuk membuat request itu harus menunggu thread lain yang belum selesai. Proses menunggu ini yang membuat pemanggilan ini memakan waktu lama, dan jika sudah melebihi batas waktu timeout, sistem akan merespon dengan failure.</li></ol><p>Contoh yang baru saja saya paparkan hanya proses simpel di salah satu service, bagaimana jika kita memiliki puluhan service lain yang memiliki proses dan memiliki kemungkinan besar untuk terjadi failure yang sama. Belum lagi memperhitungkan jika kita memiliki chaining call di antara microservice kita, Cart service memanggil Order service, dan Order memanggil Payment service, jika payment gagal maka order dan cart juga akan gagal, inilah yang dinamakan <strong>Cascading failure</strong>. Dalam kasus inilah Netflix Hystrix yang membawa implementasi pattern <strong>Circuit Breaker </strong>bisa menjadi solusi dalam masalah resiliensi.</p><h4><strong>Hystrix, Solusi Resiliensi</strong></h4><p>Sebelum lebih jauh membahas Hystrix, saya akan jelaskan secara singkat mengenai Circuit Breaker. Circuit Breaker sendiri adalah sebuah design pattern yang berguna untuk menghentikan sebuah request ke service apabila ditemukan masalah atau failure ketika kita berusaha untuk memanggil service tersebut. Dalam konteks elektronik di rumah kalian, mungkin juga sudah pernah dengar, yaitu sebuah switch atau saklar yang berfungsi secara otomatis untuk melindungi jaringan listrik di rumah kita dari overload maupun arus pendek, ketika salah satu itu terjadi, maka otomatis Circuit Breaker akan menghentikan seluruh aliran daya listrik di rumah kita. Cara kerja dari Circuit Breaker di rumah ini sangat mirip dengan Circuit Breaker yang kita bahas saat ini.</p><p>Hystrix sendiri bekerja dengan cara menjadi middle entity (something in between) di antara client dengan service luar yang ingin kita panggil, i.e. mengisolasi. Ketika ditemukan masalah terhadap service luar yang ingin kita panggil melalui Hystrix, secara otomatis Hystrix akan Fail Fast (gagal dengan cepat ketika ada indikasi failure) dan tidak akan memanggil service luar kembali untuk beberapa waktu. Sebagai gantinya Hystrix akan mengembalikan response fallback yang sudah kita atur. Dengan ini, sistem yang kita buat akan terisolasi, tidak akan sepenuhnya failure, dan tetap bisa memberikan response fallback untuk sementara waktu.</p><p>Dalam konteks user experience, prinsip-prinsip yang dibawa Hystrix sangat bagus. Bayangkan ketika kita ingin mengecek barang pesanan kita sudah sampai mana, tetapi sistemnya sangat lemot dan membuat kita menunggu lama, pasti sebagai user kita sangat kesal. Jadi lebih baik langsung kita berikan responnya dengan cepat, tidak peduli apakah fail ataupun success, ini lebih baik daripada harus memaksa user untuk menunggu lama.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/759/1*H6hlFl79Mx6zn_U1ktt1gw.png" /><figcaption><a href="https://martinfowler.com/bliki/CircuitBreaker.html">https://martinfowler.com/bliki/CircuitBreaker.html</a></figcaption></figure><p>Di atas adalah diagram siklus sederhana bagaimana Circuit Breaker dalam Hystrix bekerja.</p><ol><li>Dalam keadaan normal, Circuit Breaker berada dalam kondisi <strong>Closed. </strong>Dalam keadaan ini, semua request yang dikirimkan ke service luar mengalir dalam keadaan normal.</li><li><strong>Open</strong> adalah keadaan apabila terjadi sebuah failure ketika memanggil service luar, dan failure tersebut sudah melampaui threshold (ambang batas). Dalam keadaan ini aliran request ke service luar akan dihentikan dan sistem akan return error atau fallback yang sudah diatur sebelumnya.</li><li>Ketika sudah lewat beberapa waktu, keadaan akan berubah ke <strong>Half Open. </strong>Dalam keadaan ini aliran request akan dikirimkan kembali ke service luar dengan batas yang sangat sedikit untuk menguji apakah masih terjadi failure atau tidak. Apabila sudah aman, maka keadaan akan kembali ke Open. Jika masih terjadi failure, keadaan akan kembali ke Closed dan siklus akan berulang terus menerus.</li></ol><p>Semoga dengan apa yang saya paparkan di atas menjadi pengetahuan baru untuk kalian yang sedang mendalami software engineering dalam level yang lebih dalam, saya berusaha untuk menggunakan bahasa dan istilah yang mudah dipahami agar tidak terlalu pusing, cukup waktu implementasi saja kita pusing, setidaknya ketika membaca teori kita bisa langsung paham dan dapat pengetahuan baru. Apabila ada kritik ataupun saran, bisa disampaikan lewat akun twitter saya @<a href="https://twitter.com/roketempur">r</a>oketempur. Sekian dan terima kasih.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f2843def9956" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>