<?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 Teofanus Gary on Medium]]></title>
        <description><![CDATA[Stories by Teofanus Gary on Medium]]></description>
        <link>https://medium.com/@garyteofanus?source=rss-ae6f1b4364c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*xO67oW2hSzH1MFKwLk-Hlg.jpeg</url>
            <title>Stories by Teofanus Gary on Medium</title>
            <link>https://medium.com/@garyteofanus?source=rss-ae6f1b4364c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 04:04:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@garyteofanus/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[Exploring the Process of Creating Mockups]]></title>
            <link>https://garyteofanus.medium.com/exploring-the-process-of-creating-mockups-f3df1350e6b2?source=rss-ae6f1b4364c------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3df1350e6b2</guid>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Teofanus Gary]]></dc:creator>
            <pubDate>Mon, 21 Mar 2022 14:28:31 GMT</pubDate>
            <atom:updated>2022-03-21T16:19:13.116Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z2GVCQQazQXU30FXYmGWTw.png" /><figcaption>10 Nielsen’s Heuristics</figcaption></figure><p>To create a good mockup, you need to have a good guidelines to avoid making mistakes. One of the guidelines is called 10 Nielsen’s Heuristics. Below, I will show how our team create a mockup that follow 10 Nielsen’s Heuristics.</p><h3>Visibility of System Status</h3><blockquote>The design should always keep users informed about what is going on, through appropriate feedback within a reasonable amount of time.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*ChTEzvtUBOWCKzbQrtAGFA.png" /></figure><h3>Match between system and the real world</h3><blockquote>The design should speak the users’ language. Use words, phrases, and concepts familiar to the user, rather than internal jargon. Follow real-world conventions, making information appear in a natural and logical order.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*fw_AfSslQlEvvgidZJfkkQ.png" /></figure><h3>User control and freedom</h3><blockquote>Users often perform actions by mistake. They need a clearly marked “emergency exit” to leave the unwanted action without having to go through an extended process.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*Ybh0HnaCud__kd1auMKI3g.png" /></figure><h3>Consistency and standards</h3><blockquote>Users should not have to wonder whether different words, situations, or actions mean the same thing. Follow platform and industry conventions.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*EZSPtxWoPIq50yPavmIhYA.png" /></figure><h3>Error prevention</h3><blockquote>Good error messages are important, but the best designs carefully prevent problems from occurring in the first place. Either eliminate error-prone conditions, or check for them and present users with a confirmation option before they commit to the action.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YjXYoNdVpkJCR8b5btjE-A.png" /></figure><h3>Recognition rather than recall</h3><blockquote>Minimize the user’s memory load by making elements, actions, and options visible. The user should not have to remember information from one part of the interface to another. Information required to use the design (e.g. field labels or menu items) should be visible or easily retrievable when needed.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*-Ep-G3eNhbMMx_4dCxCBPQ.png" /></figure><h3>Flexibility and efficiency of use</h3><blockquote>Shortcuts — hidden from novice users — may speed up the interaction for the expert user such that the design can cater to both inexperienced and experienced users. Allow users to tailor frequent actions.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*aoM_emLlMSUYcW9QBgNZqA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*U5Cxqu4EX5jSui9NS8JN2A.png" /></figure><h3>Aesthetic and minimalist design</h3><blockquote>Interfaces should not contain information which is irrelevant or rarely needed. Every extra unit of information in an interface competes with the relevant units of information and diminishes their relative visibility.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*8L-DMy2PCG_u4PQWvhxyLA.png" /></figure><h3>Help users recognize, diagnose, and recover from errors</h3><blockquote>Error messages should be expressed in plain language (no error codes), precisely indicate the problem, and constructively suggest a solution.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*0J5kHxDk43tzBsy0NN6wjA.png" /></figure><h3>Help and documentation</h3><blockquote>It’s best if the system doesn’t need any additional explanation. However, it may be necessary to provide documentation to help users understand how to complete their tasks.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*G5XRrwvm-pHFQXqleYP3Mg.png" /></figure><h3><strong>References</strong></h3><ul><li><a href="https://www.uxness.in/2015/02/10-heuristic-principles-jakob-nielsens.html">10 Heuristic Principles - Jakob Nielsen&#39;s (Usability Heuristics)</a></li><li><a href="https://www.nngroup.com/articles/ten-usability-heuristics/">10 Usability Heuristics for User Interface Design</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3df1350e6b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Scrum Journey]]></title>
            <link>https://garyteofanus.medium.com/my-scrum-journey-a5e6b6f17951?source=rss-ae6f1b4364c------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5e6b6f17951</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[scrum]]></category>
            <dc:creator><![CDATA[Teofanus Gary]]></dc:creator>
            <pubDate>Mon, 21 Mar 2022 13:27:41 GMT</pubDate>
            <atom:updated>2022-03-21T13:27:41.557Z</atom:updated>
            <content:encoded><![CDATA[<p>In this article, I’m going to tell a story about my journey using scrum software methodology for Software Engineering Project coursework on University of Indonesia.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3i5Er55Y2ZwaLCTRqo2vog.jpeg" /><figcaption>Scrum Framework</figcaption></figure><p>Scrum is a framework for software development process. Scrum defines roles and provide guidelines for a software development process that addresses weak point that might happend in software (product) development.</p><h3>Scrum Roles</h3><h4>Product Owner</h4><p>A product owner’s main focus is to set a clear direction on where the project will take course. A product owner must ensure that the team are delivering the most value and have a strong connection between <strong>business stakeholder</strong> and the development team.</p><h4><strong>Scrum Master</strong></h4><p>The role of scrum master is to glue everything and making sure that scrum being done well. The scrum master also make sure that any setbacks in the current sprint fixed in the next sprint, effectively improving the scrum team.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rIqT0JZkxExSwGcM3I_TDg.png" /></figure><h4>Development Team</h4><p>The development team do the work to create a shippable software (deliverables). To do this, they communicate and work with each other throughout the process of scrum.</p><h3>How our Team</h3><h4>Pre-Sprint</h4><p>The first step in scrum framework is to plan the whole sprint process which in my groups lasts around 3 weeks. In this step, we make a PBI (Product Backlog Item) which is a breakdown of the task we need to do in the later sprint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rKjkxBZknMpr30uTmXkumw.png" /><figcaption>Sneak peek of our PBI</figcaption></figure><p>Along with PBI, we also create PRD (Product Requirements Diagram), which defines the value or purpose of a product. The value of the product usually includes a description of a feature in that product and the value that it brings to user.</p><h4>Sprint Planning</h4><p>Sprint planning is done at <strong>the beginning of every sprit.</strong> The purpose of sprint planning is to prepare the task to be done in that sprint. We use kanban board to manage our tasks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1vnTpPKn1Wfg0fp43JkssA.png" /><figcaption>We use JIRA to track backlog</figcaption></figure><p>After breaking down the task, we assign a story point to each task according to the weight of each task. The tools we use to do this is called <a href="https://www.scrumpoker-online.org/">scrum poker</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KHpOo5bmNVeJkxrU2pyWaQ.png" /><figcaption>Scrum poker</figcaption></figure><p>After assigning story point, we assign each task to a development team according to their capabilities.</p><h4>Daily Stand Up</h4><p>The daily stand up is kinda like a checkup for your progress or a status report. A daily stand up usually only last for a short amount of time, around 15 minutes. Our team does stand up twice a week.</p><h4>Sprint Review</h4><p>Sprint review is when the result of the sprint is evaluated. On our project, the UAT (User Acceptance Test) is cross-checked by stakeholder with our deliverables and find out which UAT pass and which one don’t. Sprint review itself is done at the of the sprint.</p><h4>Sprint Retrospective</h4><p>The last step is sprint retrospective, which is a self reflection on what went well, what to improve, and action items (what action we will take). We use the tool easy retro to do this.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a-FdoZh-umjhrZLXrEPQYg.png" /></figure><h4>Conclusion</h4><p>Scrum is a pretty nice way to organize your team effectively and manage deliverables especially in a rapid environment where an incremental progess must be made.</p><h4><strong>References</strong></h4><ul><li><a href="https://www.atlassian.com/agile/scrum/roles">Agile Scrum Roles | Atlassian</a></li><li><a href="https://www.digite.com/agile/scrum-methodology/">What Is Scrum Methodology? &amp; Scrum Project Management</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5e6b6f17951" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Persona: Get to Know Your Users]]></title>
            <link>https://garyteofanus.medium.com/persona-get-to-know-your-users-d9f81fff0f79?source=rss-ae6f1b4364c------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9f81fff0f79</guid>
            <category><![CDATA[ui]]></category>
            <dc:creator><![CDATA[Teofanus Gary]]></dc:creator>
            <pubDate>Mon, 21 Mar 2022 13:26:42 GMT</pubDate>
            <atom:updated>2022-03-21T14:44:40.077Z</atom:updated>
            <content:encoded><![CDATA[<p>Now, you might wonder what is persona and how does it helps you to get to know the userbase of your application. Well, buckle up because I’m going to tell you about Persona.</p><h3>The What</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/671/1*aa_CAufUmBt0QGEE1s5A0w.png" /></figure><p>Persona is a fictional character created to represent the goals and characteristics of a user or a group of user for your application. Persona is usually created by a designer and include behavior patterns, goals, skills, attitudes, and background information, as well as the environment in which a persona operates. A persona is usually create as realistic as possible. A persona consists of name, photo, goals and needs, frustrations, behaviors, and some personality.</p><blockquote>Wow, that’s some theories. But why create Persona at all?</blockquote><h3>The Why</h3><p>Imagine you have a really good development team and a really good idea for an app. To make the app successfull, we need to understand what the user actually needs and wants, in other words “Who are we designing for?”. The answer to that is user persona. By understanding the expectations, concerns, and motivations of target users, we can design a product that satisfy the user needs and wants.</p><p>Creating persona also has benefits, like:</p><ol><li>Gain perspective of a possible user</li><li>Identify the target user</li></ol><blockquote>Now I want to create persona too! But how?</blockquote><h3>The How</h3><h4><strong>Research!</strong></h4><p>The first step is to collect as much data about the user as possible. From that data we can understand the target audience’s mindsets, motivations, and behaviors. There are a few ways to collect data, for example:</p><ol><li>Surveys, create a form that is distributed to users.</li><li>Interviews, usually the best way to collect data, prepare a list of non-leading and open ended questions to ask to some number of user in a session.However there are pitfalls, you need to choose a good amount of <strong>varied </strong>user. If the collected data is from a homogenous user, then that collected data doesn’t amount that much.</li><li>Observation, observe some user to know their behaviour.</li></ol><h4><strong>Identify behavioral patterns from research data</strong></h4><p>After collecting a bunch of data, analyze that data. The result will be used to form a pattern of user that we can categorized. This pattern can be our base of persona.</p><h4>Create persona</h4><p>Construct the analyzed data into a user persona. At this step, don’t add too many personal information (too many personalities) that does not reflect the actual user. Remember that a persona must be generic enough to represent a group of user. Usually, there are more than one persona for a product. If you create more than one persona, tag a primary persona or lead persona.</p><h4>Crate scenario UX</h4><p>Personas have no value in and of themselves. You need to tie them up to create a scenario. Scenario is an fictional situation that describes how a persona would interact to achieve its end goal(s). Scenarios should be written from the persona’s perspective, usually at a high level, and articulate use cases that will likely happen.</p><h4>Share your findings</h4><p>After finishing your persona, share the result with the rest of the team to get feedback. This step is important as the user persona must be excellent. If there are mistakes, sometimes the whole process need to be repeated again.</p><blockquote>Nice! I understand, but can you give me a concrete example?</blockquote><h3>The Example</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K-lPCPLIMj3bwuTkjKiVyQ.png" /><figcaption>Example persona of a student</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cTyYYTZjfKHCr_-wWrrKwQ.png" /><figcaption>Example persona of a standup comedian</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b2249TEoDFJ-evP-bvReeg.png" /><figcaption>Example persona of a content merketer</figcaption></figure><p>The three persona above are example of persona we created and used on our project, an app to aggregate hangout places.</p><h3><strong>Conclusion</strong></h3><p>Persona is a great way to represent your userbase and get to know what your user need and goals. User persona also helps to help you build a successfull product.</p><h3>References</h3><ul><li><a href="https://www.interaction-design.org/literature/article/personas-why-and-how-you-should-use-them">Personas - A Simple Introduction</a></li><li><a href="https://xd.adobe.com/ideas/process/user-research/putting-personas-to-work-in-ux-design/">What Are User Personas and Why Are They Important? | Adobe XD Ideas</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9f81fff0f79" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Short Intro to Dockerize Go(lang) REST API]]></title>
            <link>https://garyteofanus.medium.com/short-intro-to-dockerize-go-lang-rest-api-5f0fd7d995d0?source=rss-ae6f1b4364c------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f0fd7d995d0</guid>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Teofanus Gary]]></dc:creator>
            <pubDate>Mon, 28 Feb 2022 13:35:30 GMT</pubDate>
            <atom:updated>2022-03-01T22:51:50.376Z</atom:updated>
            <content:encoded><![CDATA[<p>Go(lang) is a programming language that’s good to create a backend for web application. We will use Go as the language for a simple REST API that we will Dockerize.</p><p>Before we go through over the steps, here’s some reason why you might want to consider dockerizing your REST API:</p><ul><li>Consistent development environment, using Docker, you and your team can have matching dev environment. This eliminates the problem that arise from using different setup like different version of some dependency. Not only your team, but your production server can also have the same setup as the development setup that you and your team use.</li><li>Mobility, with Docker, you can run your environment everywhere, on different operating systems, on different hardware, etc.</li></ul><p>Now continue to the steps, first we imagine you already have a working simple REST API that uses PostgreSQL as database. You can use this Dockerfile</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cdc9f4da5b6f68a8348ce0ab772e7de3/href">https://medium.com/media/cdc9f4da5b6f68a8348ce0ab772e7de3/href</a></iframe><p>Here, we use what’s called a multi stage build for our Dockerfile. That means that we are using two images, one for building our source code into a binary and the other images is for hosting our binary. The benefit of this is that the resulting image is <em>much smaller</em> than if we are not using multi stage build.</p><p><strong>The commands</strong></p><ul><li>Line 1–3 setup our build image (which is alpine) and install a certificates.</li><li>Line 6–7 copy the dependency file of our go rest api source code and download it.</li><li>Line 9–10 compiles our source code into a binary called ‘myapp’</li><li>Line 13–18 setup another image and copies our binary from step before and then run it while exposing port 8080.</li></ul><p>You can go ahead and build that Dockerfile using docker build myapp . , that command will build our Dockerfile into an image. After it finished, we can run docker run -dp 8080:8080 myapp. <em>Voilla! </em>If there are no problem your app should be up and running. Now, we go to the next step.</p><p>You might be wondering how to setup our database, do we need to run another container to host our database? No, you can use docker compose to help you with that. Docker compose is a tool that is used to manage a multi container application. You can see below to see an example docker compose file.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f8b134ed07226ed85c85f180bfbfec5a/href">https://medium.com/media/f8b134ed07226ed85c85f180bfbfec5a/href</a></iframe><p>Here we setup 2 services: postgres (our database server)and myapp (our REST API). Our postgres service will pull a postgres image and setup some environment needed (you can configure it with a .env file but we already set a default). Our myapp service, will use our Dockerfile to build an image and since myapp service is dependent to the databasem we use depends_on to make sure the database is ready.</p><p>Try running it with docker-compose up . Congrats! You now have a golang REST API and a database.</p><h4>References</h4><p><a href="https://hentsu.com/docker-containers-top-7-benefits/">Docker Containers: Top 7 Benefits of Docker Containerization</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f0fd7d995d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Should You Use TDD?]]></title>
            <link>https://garyteofanus.medium.com/should-you-use-tdd-dc5b6268f2c8?source=rss-ae6f1b4364c------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc5b6268f2c8</guid>
            <category><![CDATA[tdd]]></category>
            <dc:creator><![CDATA[Teofanus Gary]]></dc:creator>
            <pubDate>Mon, 28 Feb 2022 11:52:48 GMT</pubDate>
            <atom:updated>2022-06-22T08:16:51.916Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>“Regression testing”? What’s that? If it compiles, it is good; if it boots up, it is perfect.“</blockquote><blockquote>- Linus Torvalds</blockquote><h3><strong>Quick Recap</strong></h3><p>TDD (Test Driven Development) is a software development process that tightly knit together three 3 activities, namely testing; coding; and refactoring in that order. This activities is sometimes reflected in the corresponding commit messages with a word [RED], [GREEN], and [REFACTOR].</p><figure><img alt="TDD Cycle" src="https://cdn-images-1.medium.com/max/996/0*V89Kgx68OY6YgBNq.jpeg" /><figcaption>TDD Cycle</figcaption></figure><h4>[RED] Write failing test</h4><p>In this cycle, write a test for a feature we want to create. The test we write must fill all the requirements of the feature we want to implement meaning that we need to test for failure (if exist) as well as success condition.</p><p>Here are some tips to write a good test:</p><ul><li>Don’t test implementation detail, test behaviour/business logic. Imagine you have a function that is calculating distance between two points using euclidean distance. Instead of testing the euclidean logic itself, consider testing that a given input gives the correct output regardless of the logic. Why? Because that makes the test less brittle and need to be changed if, for example we want to change from euclidean distance to manhattan distance.</li><li>Don’t write too much test, write the test according to the feature specification.</li></ul><h4>[GREEN] Write implementation that pass the test</h4><p>In this cycle, write a feature implementation that makes the test we created before pass. Don’t write too much code but only the minimal amount that makes the test(s) pass.</p><h4>[REFACTOR] Refactor the implementation</h4><p>In this cycle, refactor the implementation that’s written in the cycle before. Remember that refactoring does <strong>not </strong>change behaviour, refactoring only changes the implementation detail, so you need to make sure that this cycle also pass the test.</p><p>Given the explanation about the intrinsic detail of TDD, let’s continue to the why would you want to use TDD.</p><h3>Advantages of TDD</h3><ul><li>More maintainability, with TDD, developer can write a smaller chunks of code that pass the test for requirements. This can result in easier management and modularity of code.</li><li>Less debugging, TDD enforce testing and can found error faster and in a shorter timeframe. This is one of the biggest advantage of TDD.</li></ul><h3>Disadvantages of TDD</h3><ul><li>Development process slows down, writing test costs time even more so for good test. The need to write test before writing the implementation may cost valuable time.</li><li>TDD is hard to learn and master. To implement TDD, developer needs consistently write a good test that fit all the requirements.</li></ul><h3>FIRST Principle</h3><p>The FIRST principle help to create well-written unit tests. As unit tests is an integral part of TDD, creating a well-written can lead to an easy time applying TDD.</p><ul><li><strong>F</strong>ast: run (subset of) tests quickly<br>Test need to run quickly so you can easily run it again and again. In our group project, we use dependency injection, to make sure only the core unit is being tested, this reduces the complexity of the unit test as well decreases the running time.</li><li><strong>I</strong>ndependent: no tests depend on others, so can run any subset in any order</li><li><strong>R</strong>epeatable: run N times, get same result (to help isolate bugs and enable automation)</li><li><strong>S</strong>elf-checking: test can automatically detect if passed (no human checking of output)</li><li><strong>T</strong>imely: written about the same time as code under test (with TDD, written first!)</li></ul><h3>Conclusion</h3><p>TDD has it’s own merit and using TDD in a project can bring many benefits that may make your life easier. On the other hand, TDD is not easy to use correctly. In the end, it all boils down to what your team capabilities, time constrains, and project requirements.</p><h4>References</h4><ul><li><a href="http://agileinaflash.blogspot.com/2009/02/first.html">F.I.R.S.T</a></li><li><a href="https://www.agilealliance.org/glossary/tdd/">What is Test Driven Development (TDD)?</a></li><li><a href="https://fortegrp.com/test-driven-development-benefits/">How test-driven development help business: benefits of TDD | Forte Group</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc5b6268f2c8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using Git Like A Pro]]></title>
            <link>https://garyteofanus.medium.com/using-git-like-a-pro-b3ad5ef61e94?source=rss-ae6f1b4364c------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3ad5ef61e94</guid>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Teofanus Gary]]></dc:creator>
            <pubDate>Mon, 28 Feb 2022 07:23:29 GMT</pubDate>
            <atom:updated>2022-02-28T07:23:29.823Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Source code control the way it was meant to be!</blockquote><blockquote>- Linus Torvalds</blockquote><p>Git is a common tool that a <strong><em>lot </em></strong>of developer should have heard and used. Git really shine the brightest when used to collaborate with other developers. Personally, I’ve used git to collaborate with other developers for around 4 years. Along the way, I’ve picked up some tips on how to use git.</p><h4><strong>Rebase vs Merge</strong></h4><p>You might have heard about git merge, but how about git rebase? Both of them has the same purpose, combining two divergent branches, but do it in a totally different way!</p><p>Imagine a scenario where you have a commit log like this. You have a master branch and two divergent feature branch (namely rebase-branch and merge-branch). You want to merge those two feature branch back to the master branch. You can do that in two ways, using git merge and git rebase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d-JmDU2Bh1oTZyKYyf7sgw.png" /></figure><p>Using git merge will make the result looks image below. There’s a merge commit line on the log and with a complex merge, those commit lines get out of hands really quickly. So, the alternative is using git rebase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i5E7Lt3MkAZ7ZcV_8Ybc2A.png" /><figcaption>Using git merge</figcaption></figure><p>By using git rebase, the commit is put on top of the master branch and make it looks like a direct commit after the latest commit on the master branch. The resulting git log looks much cleaner.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OmT7bbB4a6M5pxMbrQiSwA.png" /><figcaption>Using git rebase</figcaption></figure><p>A word of warning, git rebase is <em>destructive operation, </em>meaning that it change a branch history and can make your life harder. This behavior is different than git merge which is a <em>non-destructive operation.</em></p><h4>Writing A Good Commit Message</h4><p>Take a look at this wonderful blog post by David Thomposon</p><p><a href="https://dhwthompson.com/2019/my-favourite-git-commit">My favourite Git commit</a></p><p>There are several key points that can be taken from that post:</p><ul><li>A commit message must contain a header that shortly describe <strong>what </strong>changes is made. One way to do that is to complete this sentence “if applied, this commit will &lt;commit message&gt;”.</li><li>A commit message also needs to explain <strong>why </strong>this change is needed. A good way is to add a more descriptive paragraph one line break after the commit header.</li></ul><p>Applying those principle to all commits is arguably pretty hard. But those points show that a good commit message matters and can make everyone life easier.</p><h4>Merge Request/Pull Request</h4><p>Merge request is a request from someone to merge on branch to another branch. This feature is commonly used in collaboration to merge one feature branch to a master branch. Using merge request can have several benefits:</p><ul><li>Reviews, a merge request wont be immediately merged to the target branch. Instead, the creator of merge request can ask for <em>reviews </em>from other developer to get feedback.</li><li>Squash, squashing commit messages is used to <em>squash </em>multiple commit message into one. By squashing you can avoid littering commits to your target branch.</li></ul><h4><strong>References</strong></h4><p><a href="https://www.atlassian.com/git/tutorials/merging-vs-rebasing">Merging vs. Rebasing | Atlassian Git Tutorial</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3ad5ef61e94" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>