<?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 Anastasia Audi on Medium]]></title>
        <description><![CDATA[Stories by Anastasia Audi on Medium]]></description>
        <link>https://medium.com/@anastasiaaudiw?source=rss-f1cd82e8b764------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*RIAUjOQKQnwonlXNvSYmRw@2x.jpeg</url>
            <title>Stories by Anastasia Audi on Medium</title>
            <link>https://medium.com/@anastasiaaudiw?source=rss-f1cd82e8b764------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 17:16:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@anastasiaaudiw/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[Design System is the answer to your UI struggles]]></title>
            <link>https://medium.com/@anastasiaaudiw/design-system-is-the-answer-to-your-ui-struggles-3049347f3155?source=rss-f1cd82e8b764------2</link>
            <guid isPermaLink="false">https://medium.com/p/3049347f3155</guid>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[ui-ux-design]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Anastasia Audi]]></dc:creator>
            <pubDate>Wed, 07 Dec 2022 09:55:32 GMT</pubDate>
            <atom:updated>2022-12-07T09:58:29.841Z</atom:updated>
            <content:encoded><![CDATA[<h3>Design System is the key to your UI struggles</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/868/1*uM3N3899IkQiLLOB1cOnGA.png" /></figure><p>I used to be one of those Figma users that never take advantage of project library and design systems. I struggled so much to create my own design system because I never know the number of pixels that is suitable for a button, or what is the right size of a title text.</p><h3>What is Design System?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wp8zHx3WcSL3qAg6RM5PAQ.png" /><figcaption>iSaveit components library</figcaption></figure><p>Having a well-defined design system is essential for creating a cohesive and consistent user experience. Without a set of standards, it is difficult to ensure that the user experience is consistent across different platforms and devices. By referring to related workflows and experience from common and established works, designers can ensure they are creating a user-friendly and intuitive interface.</p><p>Design guidelines provide the team with an anchor to base their designs on. They provide design parameters, such as colour palettes, typography, and spacing, that will help create a consistent look and feel throughout the product. These design guidelines should be tailored to the team’s specific needs and should be updated as the product evolves.</p><h4>The key to creating effective design guidelines is</h4><p>to thoroughly research existing works. This can be done by studying popular websites and mobile apps, analyzing existing user interface designs, and looking at the best practices of other teams. By studying existing works, designers can gain insight into the current trends and understand the most successful design solutions.</p><p>Once the team has identified the design parameters, they should begin to define the team’s design guidelines. This should include assets and styles to ensure the team is creating a consistent and cohesive user experience. Assets should include color palettes, typography, icons, illustrations, and logos that can be used across the product. Styles should define the spacing, layout, and interactions that should be implemented.</p><p>Creating effective design guidelines is a complex process, but it is essential for creating a consistent user experience. By referring to related workflows and experience from common and established works, and following a determined standard design guideline, teams can ensure they are creating a user-friendly and intuitive interface.</p><h3>Tips for Begineer UI/UX Designers out there 🪄</h3><p>As I said before, crafting your design guideline from scratch can take literally so much of your time because of the many components you need to create and focus on. So I’ll be sharing what I’ve been doing as a UX Designer whenever I need to make a design system.</p><h4>1 — Decide on your color palette</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g5g_Gcq4RUlubAtpKQIsTQ.png" /></figure><p>This is a crucial and long step because you need to browse many references and brainstorm to decide on your primary color palettes. And this is very crucial because it will define the brand of your product, so make sure your decision is made wisely 👍🏼</p><p>🎨 Random Color generator: <a href="https://coolors.co/">https://coolors.co/</a></p><h4>2 — Explore design system communities on Figma</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7Popa5jFRJffOsmnnyGewg.png" /></figure><p>I guess this is the best tip out there, because you wont need to waste your time to fix the number of pixels of your button, or fix the padding between your texts. There are many FREE design system template out there, and its just a click away. Here are some templates I’ve been using:</p><ol><li>Nucleus UI Design System</li><li>Xela UI Kit</li><li>Fabrx Web Design System</li><li>Web Pixels Design System</li></ol><h4>3 — Publish your Figma library and use it for your project</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/974/1*g1LRtTEywZbdwHL-FumLGA.png" /></figure><p>This is such an important step, yet I forget to do it most of the time. Do not forget to publish your design components to your figma library, so you can then import it to other figma project files. By doing this, you can easily access all the components you’ve created through the assets navbar on the left.</p><p>Well that is all the basic things you need to know as a designer about design system. Hope this article helps you in any way, and you can start implementing this system on your next project 👋</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3049347f3155" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Refactoring and Continous Integration]]></title>
            <link>https://medium.com/@anastasiaaudiw/refactoring-and-continous-integration-6a73b3037fe1?source=rss-f1cd82e8b764------2</link>
            <guid isPermaLink="false">https://medium.com/p/6a73b3037fe1</guid>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[integration]]></category>
            <category><![CDATA[sonarcloud]]></category>
            <dc:creator><![CDATA[Anastasia Audi]]></dc:creator>
            <pubDate>Wed, 07 Dec 2022 09:30:02 GMT</pubDate>
            <atom:updated>2022-12-08T00:36:18.233Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UGMhYwJjIpDljxRFIL61mQ.png" /></figure><p>Continuous integration and refactoring are two of the most critical aspects of software development. In this article, I will explain refactoring and continuous integration, as well as the implementation of my computational project, iSaveit.</p><h3>Continuous Integration (CI)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YalBo8Zz_zW2fwfT.jpg" /><figcaption>Semaphore CI</figcaption></figure><p>Continuous integration is the practice of integrating code changes as soon as they are made, so that the project is always up to date and any bugs or errors can be identified quickly. With continuous integration, developers are able to rapidly iterate on their program, lowering the risk of bugs while increasing their output. Engineers can save time and effort by automating the process of building and testing their code thanks to continuous integration. More so, the CI outcomes will be communicated to the developers. If the CI passes, then the development process will move on to the next phase, which might be anything from deployment to some other phase.</p><p>Continuous integration also helps teams to keep up with the pace of development. By integrating code quickly and frequently, teams can ensure that they are able to release products on time and with the highest quality. This helps to ensure that their products are of the highest quality and can meet the needs of their customers.</p><h3>Refactoring</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uJ_Dz_VGefw70v3ymXQMwg.png" /></figure><p>Refactoring is the process of restructuring existing code to improve readability, maintainability, and performance without changing its external behaviour.</p><p>When refactoring, developers break down existing code into smaller, simpler parts. This helps to improve readability and maintainability. Developers can also use refactoring to improve performance by removing redundant code or replacing slow algorithms with faster ones. Refactoring can also help to reduce complexity by introducing abstraction and making code more modular.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FT59pnOiP5xMBwKAf-Jnhw.png" /><figcaption>delete pocket function from iSaveit using Django framework</figcaption></figure><p>A good example of refactoring is the process of extracting a function. This is when a function is extracted from an existing codebase and given its name. This helps to make code more readable, as it is easy to see what the function does. This also makes the code easier to maintain, as it is easier to make changes to a single function than to the entire codebase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zHX2As5Zch22cCKI6MuUeg.png" /><figcaption>Refactor commit message on iSaveit</figcaption></figure><p>Another example of refactoring is when you make changes to your code whether its for update, fixing bugs, or making minor changes on the logic of the feature. My team implements the labelling of our git commit with <strong>[REFACTOR]</strong> to indicate that the changes we made are for refactoring purposes only.</p><h3>Sonarcloud as code analysis tool</h3><p>SonarCloud is a cloud-based code analysis platform that provides automated code analysis and refactoring. It helps to identify bugs and code smells and provides automated refactoring suggestions that can help developers to improve their code. My team uses Sonarcloud because it helps to reduce the manual effort required to refactor code, making it faster and easier for us to improve code quality.</p><p>Every time we checkout a new branch for a feature implementation, we always create a pull request before merging the branch to staging. In this pull request, there are some checks that inform us the success of our program after every push.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ugAWT5wqlhIIOz009K1DJw.png" /></figure><p>As you can see, the SonarCloud code analysis failed because there are some problems found on the branch after a push.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1hJ203FRwNmGPF3Tqp65ug.png" /></figure><p>The sonarcloud then commented on the pull request of which components failed. On the example above, it shows that there are 2 Security hotspots found on the branch. But luckily, there are no bugs or code smells 👍🏼</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gVl9VlWHHQaqQ6WdLSzcBA.png" /></figure><p>Furthermore, if we click on the hotspots found, it will lead us to the sonar cloud website, where a dashboard will display the summary of all issues found on the branch. One thing I like about sonar cloud is that it also give recommendation of solutions to the problem or issues we encounter.</p><p>Well, that is all from me. Hope this article helps you in any way, and happy coding 😊</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a73b3037fe1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Maintain and Developing your Software]]></title>
            <link>https://medium.com/@anastasiaaudiw/maintain-and-developing-your-software-fd694f7d6d75?source=rss-f1cd82e8b764------2</link>
            <guid isPermaLink="false">https://medium.com/p/fd694f7d6d75</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[system]]></category>
            <category><![CDATA[software-engineer]]></category>
            <dc:creator><![CDATA[Anastasia Audi]]></dc:creator>
            <pubDate>Wed, 23 Nov 2022 16:29:02 GMT</pubDate>
            <atom:updated>2022-11-24T00:50:26.928Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*wfwrMZc13hNcKJytGa7QFQ.png" /></figure><p>It is crucial to constantly develop maintainable software because software always needs new features or bug fixes. By maintaining it, you can easily extend and fix your code. In this article, I’ll try and spare you the confusion by simply explaining some important terms to help you understand the deployment and operation in a software.</p><h3>Software Architecture 🪜</h3><blockquote>Just by making the architect role explicit, a team can effectively resolve many technical conflicts. — Yegor Bugayenko</blockquote><p>Ever heard of software architecture? Well, it’s simply the organization of your system that represent the design decisions related to the overall system structure and behaviour. Your software architecture will serve as the blueprint for your system by providing the visualization of how each of the system’s components are connected to each other. It helps you organizing your components into a system. But, what are these components?</p><ol><li><strong>Implementation details</strong> ➡️ the folder structure of your repository</li><li><strong>Implementation design decisions </strong>➡️ server side or client side rendering? relational or non-relational database?</li><li><strong>Implemenation technologies</strong> ➡️ Is it Django or Node framework?</li><li><strong>System design decisions</strong> ➡️ monolith system or microservices?</li><li><strong>Infrastructure decisions</strong> ➡️ do you use a cloud provider or do you host the software on premise?</li></ol><p>Here’s a <a href="https://www.lucidchart.com/blog/how-to-design-software-architecture"><strong>link</strong></a> to an article I find helpful when it comes to creating my own software architecture 📐✏️</p><h3>Moving on, what is DevOps? 👨🏻‍💻</h3><p>After familiarizing yourself with a brief introduction to software architecture, lets understand DevOps. So, DevOps is a concept where developers and operation teams are collaborating to innovate the software faster. Sometimes its known as a role, and other understand it as a philosophy that require certain mindset, tools, and skills. By automating infrastructure, workflow, pipeline, and continuously monitoring application performance, <strong>DevOps connects development and operation teams to enhance collaboration and productivity.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/565/0*hh6zmi01-P_FhUyJ.png" /></figure><h4>Three phases of DevOps implementation</h4><p><strong>1 — Automated Testing</strong> involves writing test cases within the code so that every modification made in the code can be evaluated whether the test failed or not.</p><p><strong>2 — Continuous Integration</strong> is when we use a tool that can have servers running the test code through every iteration to find out if it can create any bug in an automated way. This tool will then generate a report to inform us the test results (code coverage, failed tests, etc).</p><p><strong>3 — Continuous delivery</strong> is similar to the deployment pipeline where the entire software release cycle is automated. Every time a revision is committed, a flow that is automated builds, tests, and stages the update is started. The developer then initiates the final decision to deploy to a live production environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n9TkivmRNjN64xTl.png" /><figcaption>Continuous delivery flow</figcaption></figure><h3>Error Handling 🛠</h3><p>As developers, its definitely a goal to write a good runnable code and have your program run as you’d hope without running into any unexpected challenges along the way. However, its very common to encounter yourself with an error. Programmer errors are typically dealt with by locating and repairing them, while genuine errors are handled by having the code check for them and take the appropriate action to fix them (for example, asking for the name again), or at the very least fail in a clear and well-defined manner.</p><p>Error handling is the respond and recovery from an error condition in your software application. It works by skipping an error found in your code and allowing the system to move on to the next task. Error handling can definitely help the user when they are faced with trouble when using your system. This also eases you as developers in detecting any problems or mistakes.</p><h4>But how can we fix the errors?</h4><p><strong>1 — Error Prevention<br></strong>Preventing user errors will reduce the number of errors that have a user-related component. If there is no prevention, the system may experience a fatal error if a user tries to alter it in an unusual way. Giving the user a message in the event of an error is one way to carry out this precaution.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/748/1*BtzyBpUkuY46E6NdQbbD-A.png" /><figcaption>IsaveIt example on error handling</figcaption></figure><p><strong>2 — Error Recovery</strong><br>Fix the user’s error by allowing them to do undo or cancel action in the system.</p><h3>References</h3><p><a href="https://medium.com/@joander244/error-handling-534eb97812b9">Error Handling</a> — Joshua Alexander</p><p><a href="https://medium.com/geekculture/what-is-devops-in-simple-english-6550fbb129bd">What is DevOps</a> — Yann Mulonda</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fd694f7d6d75" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is Software Testing?]]></title>
            <link>https://medium.com/@anastasiaaudiw/what-is-software-testing-fdac8ffb541d?source=rss-f1cd82e8b764------2</link>
            <guid isPermaLink="false">https://medium.com/p/fdac8ffb541d</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Anastasia Audi]]></dc:creator>
            <pubDate>Sun, 20 Nov 2022 09:01:09 GMT</pubDate>
            <atom:updated>2022-11-20T09:01:09.074Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UeUStfgJWryoOIhL62zShQ.png" /></figure><p>After coding your whole program, you know that, as developers, it&#39;s possible to make mistakes, right? For instance, we can misunderstand the product requirements, miss any indentation or semicolons, or even overlook any epic requirements. Let’s not forget one of the most irritating mistakes ever is dealing with bugs 🪳</p><p>In brief, Software testing is the process of <strong>assessing and confirming that a software application or product performs as intended. </strong>Testing has advantages such as bug prevention, lower development costs, and better performance.</p><blockquote>If you don’t like unit testing your product, most likely your customer won’t like to test it either</blockquote><p>In a project, you’re probably familiar with the profession of SQA (Software Quality Assurance). QA professionals are involved in creating specialized tests before the product is launched. But as developers, let&#39;s not overlook that duty, and we need to familiarize ourselves with software testing terminologies. Developers should be confident in delivering their code and have a solid testing strategy because, ideally, QA testers tend to be optional in the development for crafting and maintaining tests.</p><h3>Testing Approaches</h3><h4><strong>1 — White box testing</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/778/1*GW7NWwzP265v4eLiYxUHRw.png" /></figure><p>White box testing is a technique that enables testers to examine and validate a <strong>software system’s internal operations</strong>, including its code, infrastructure, and integrations with external systems.</p><p>The advantage of white box testing is that it can uncover structural problems, hidden errors, or problems with specific components and achieve complete code coverage.</p><h4>2 — Black box testing</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*mw7e0BOxDWJANq_yu5uAkA.png" /></figure><p>Black box testing, which entails testing a system without being aware of its internal workings, is frequently carried out from the user&#39;s viewpoint. In order to identify how the system reacts to expected and unexpected user behaviors, the tester must provide input and watch the system&#39;s output.</p><p>All essential subsystems, including UI/UX, web or app servers, databases, dependencies, and integrated systems, are often assessed using a black box test.</p><h3>Types of Software Testing</h3><p>There are many different type of software testing, and each of them have specific strategies. I will introduce you to some of the test types:</p><h4>1 — Unit Tests</h4><p>Unit test is the lowest level because it focuses on individual methods and functions of the classes written by developers to test the stability of isolated units of code.</p><h4>2 — Integration Tests</h4><p>This test verifies that different modules used by the software work well together. This test is conducted by developers if it involves a complex integration like database or microservices.</p><h4>3 — Functional Tests</h4><p>Functional test focuses on business requirements of an application. The black box approach is a suitable approach to verify the functions.</p><h3>Understand Testing Coverage</h3><p>Test coverage is a technique that assesses the extent to which the application code is covered by our test cases and how much code is really tested during the execution of those test cases.</p><h4>What are the benefits of Test Coverage?</h4><p><strong>1 — Eliminate defects at early stages</strong> by identifying the gaps in test cases, defects, and requirements in early stages rather than later</p><p><strong>2 — Help discover and unearth areas</strong> of the program that have not been covered by a set of test case</p><p><strong>3 — Remove redundant cases</strong> that don’t make sense in the project by making the overall code lighter</p><p><strong>4 — Better coverage</strong> is always better because it leads to fewer defects and works to do at later stages</p><h4>Wait, there’s Code Coverage?</h4><p>After learning about Test Coverage, we should also get familiar with Code Coverage. This is the measure of the percentage of software code that has actually been executed and covers both automated and manual tests.</p><p><strong>Code Coverage</strong> — a quantitative measurement that helps determine how much of the code is executed while the application is running</p><p><strong>Test Coverage </strong>— a qualitative measure that helps in describing how test cases could be created using the requirements document as a guide.</p><h3>How Code Coverage Helped me in Testing</h3><p>My team and I implement software testing to test out the codes of our program. We used <a href="https://about.codecov.io/">Codecov</a> as our code analysis tool, allowing us to compare branches&#39; coverage. This tool provides information regarding the code coverage on a file, as well as describes which lines of code were executed by the test, and which were correct and which were not.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4rivvjkaxnY7BI1BqdxA6A.png" /><figcaption>codecov Report on dart file</figcaption></figure><p>As we can see in the picture above, it is the report of Codecov on one of my dart files. It shows that I have created test cases that cover about 94% of my codes. Codecov also helps in highlighting uncovered areas with red highlights.</p><h3>References</h3><p><a href="https://medium.com/@netxm/how-to-get-started-with-software-testing-9fa1ce4f2a64">Understanding Software Testing — Alex Bachuk</a></p><p><a href="https://www.ibm.com/topics/software-testing">What is Software Testing — IBM</a></p><p><a href="https://www.simform.com/blog/test-coverage/">Why Test Coverage is an Important part of Software Testing? — Simform</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fdac8ffb541d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Don’t ignore the visualization of your application]]></title>
            <link>https://medium.com/@anastasiaaudiw/dont-ignore-the-visualization-of-your-application-2880f54df744?source=rss-f1cd82e8b764------2</link>
            <guid isPermaLink="false">https://medium.com/p/2880f54df744</guid>
            <category><![CDATA[ui-ux-design]]></category>
            <category><![CDATA[designer]]></category>
            <category><![CDATA[ui-design]]></category>
            <dc:creator><![CDATA[Anastasia Audi]]></dc:creator>
            <pubDate>Mon, 07 Nov 2022 13:24:46 GMT</pubDate>
            <atom:updated>2022-11-07T23:17:04.150Z</atom:updated>
            <content:encoded><![CDATA[<h3>Have a good UI Design</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/619/0*-YUfVy5NFyOI1gFr.png" /><figcaption><a href="https://adanitcenter.com/courses/ui-ux-design/">https://adanitcenter.com/courses/ui-ux-design/</a></figcaption></figure><p>I will discuss the importance of visual design for your product which will be implemented mainly by the front-end developers.</p><p>Since you’re reading this through the medium platform, I will consider you a technology user. You may have encountered a website or an application that you find it very hard to understand what they’re offering, or you can’t seem to navigate through the website and decide to exit the website and find another that provides a better experience. The reason behind why you decided to exit those websites is because they have bad user interface design.</p><h3>What is UI Design?</h3><p>UI Design can be considered the structure or building blocks of how a website is being set up and functions to manipulate and communicate to users. It mainly focuses on the look and feels of the website or application that we interact with simply from the colors, animations, buttons or text. But don’t confuse yourself with UX and UI design because both have different purposes. UX design aims for the user experience, the processes usually involve some research and wireframing. While UI design focuses on the aesthetic of the product.</p><h3>What makes UI Design so important?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*ar85vlOXr2lQxZEX.jpg" /><figcaption><a href="https://goldliontech.com/the-importance-of-ui-ux-design-and-tips-to-a-great-usable-design/">https://goldliontech.com/the-importance-of-ui-ux-design-and-tips-to-a-great-usable-design/</a></figcaption></figure><p>The UI Design of your website will determine the primary impression you’ll receive once the users interact with your website. One thing that is so important to keep in mind is how impactful a simple change in your UI design can have on your users. It can be from a shape of button, change in color schemes, and many more might lead your users to exit the website because they are not used to the design and have a struggle to interact with it.</p><p>As a designer, you should set your users as the top priority because they are your target audience. Once the users have a good experience in your site, your website conversion rates will rocket and attract more people to visit. Which will lead to more chances your website to receive more interaction and have better opportunity to grow your customer base.</p><h3>How to have a good UI Design?</h3><h4>1 — Start with a wireframe</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v39TQL2HEHMtVnAmOxtoAg.png" /><figcaption>iSaveIt wireframe</figcaption></figure><p>Wireframe helps designers to point out the flaws in your site architecture early on before designing the hi-fi. These wireframes are usually built by the UX researcher or UX designer right after they do the user research.</p><h4>2 — Use a simple design</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/0*e0o3aAk0e2ZBT7UZ.jpg" /><figcaption><a href="https://careerfoundry.com/en/blog/ui-design/common-ui-design-mistakes/">https://careerfoundry.com/en/blog/ui-design/common-ui-design-mistakes/</a></figcaption></figure><p>Having complicated and fancy design interface can leads to many confusion and difficulties for users. You’d want to stick to simple design so that your audience can easily see what information your product is trying to offer without having any interaction confusion.</p><h4>3 — Be consistent</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MefZiR-C5GOOVpntJ1U_Jw.png" /><figcaption>iSaveit design system from <a href="https://www.figma.com/community/file/967227093809940846">https://www.figma.com/community/file/967227093809940846</a></figcaption></figure><p>It is recommended to have a design system first, before jumping into designing your high-fidelity design of the application. This can help you to be consistent in designing your app, because you need to have a consistent size of buttons, typography, or color schemes.</p><h4>4 — Don’t ignore copywriting</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rcA8dPZ4VjHcPG1D.png" /><figcaption><a href="https://usabilitygeek.com/how-ux-writing-can-help-create-good-design/">https://usabilitygeek.com/how-ux-writing-can-help-create-good-design/</a></figcaption></figure><p>It is essential to have clear copywriting so the users can understand what you’re trying to deliver through your design. Bad copywriting can lead to misunderstandings, and users might exit your website.</p><h4>5 — Do usability testing</h4><p><a href="https://medium.com/p/your-guide-to-usability-testing-998ff5249095">Usability testing</a> is a method that evaluates the product with real people and is usually conducted before and after the product is released. The test aims to identify potential problems users may experience, assess the product’s performance, and improve the overall user experience.</p><h3>References</h3><p><a href="https://www.sketch.com/blog/what-is-ui-design/">Sketch</a></p><p><a href="https://www.plego.com/blog/importance-user-interface-design/">User Interface Design Importance — UI Design Overview — Plego</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2880f54df744" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Methodology: Test-Driven Development]]></title>
            <link>https://medium.com/@anastasiaaudiw/software-methodology-test-driven-development-514a147f07e1?source=rss-f1cd82e8b764------2</link>
            <guid isPermaLink="false">https://medium.com/p/514a147f07e1</guid>
            <category><![CDATA[test-driven-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[methodology]]></category>
            <category><![CDATA[developer-tools]]></category>
            <dc:creator><![CDATA[Anastasia Audi]]></dc:creator>
            <pubDate>Mon, 07 Nov 2022 13:23:14 GMT</pubDate>
            <atom:updated>2022-11-08T00:16:09.749Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xbvgYMDvRW7EFfvIjm1Cog.png" /></figure><p>As a developer, you might’ve heard of what TDD is and might not. I’m going to try and explain to you what is Test Driven Development in brief so you can understand and implement this methodology once you’re back in coding.</p><h3>What is TDD?</h3><blockquote>Write test first, revision later</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2CRv7N9X9TXmjB1VbHnCUQ.png" /></figure><p>A software development methodology called test-driven development uses test cases to define and confirm what the code will accomplish. These test cases are generated and tested for each capability, and if the test fails, new code is produced to pass the test and make the code straightforward and bug-free.</p><h4>What are the benefits of implementing TDD</h4><p>Test-driven development will enable developers to assess and comprehend the user&#39;s needs by promoting the construction of an optimized code.</p><p>Because feedback and revisions are a necessary part of the development process, testing or adding new functionalities in the latter phases is easier.</p><p>Your test coverage will be higher than conventional models because TDD focuses on generating the test for each functionality.</p><h3>How to implement TDD?</h3><blockquote>Design and developing test for every small functionality of an application</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/475/0*FdwteTUnI0ctW8Nj.png" /></figure><h4>1 — Create a precise test</h4><p>developers write precise unit tests to verify the functionality of specific features and ensure that the test compiles so that it can execute.</p><h4>2 — Correct your code</h4><p>Once the test fails, developers need to make minimal changes to correct the code to run successfully.</p><h4>3 — Refactor your code</h4><p>If your test runs successfully, check for redundancy or any possible code optimizations to enhance overall performance.</p><h3>How I’ve implemented TDD into agile development</h3><p><a href="https://medium.com/@anastasiaaudiw/understanding-agile-software-development-7a30ae865c48">Agile development</a> is a software development framework that focuses on teamwork, collaboration, and iteration. This framework requires regular feedback to develop the final product, similar to TDD where it offers such feedback early on. TDD enhances the collaboration between the team members from both development and quality assurance team as well as clients.</p><p>My friends and I were creating an application through the Django framework, and below is an example of a test case my friends and I implemented on our group project.</p><p>The condition is for creating a payment information inputted into a form</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DdZiTvjAp7YUUZ9E0ql8Ow.png" /></figure><p>The goal of this test is to check HTTP request of creating a payment information, and this test case checks if the HTTP returns a valid/correct data according to the condition.</p><h3>Final Words</h3><p>Overall, using TDD in software development has a lot of advantages. It reduces problems and errors while also saving you time when writing code. Additionally, scaling up your code with TDD can aid with future enhancements.<br>Although I am not a TDD specialist, I’d urge all of you to attempt incorporating TDD in your next project.</p><h3>References</h3><p><a href="https://www.guru99.com/test-driven-development.html">What is Test Driven Development (TDD)? Tutorial with Example</a></p><p><a href="https://www.browserstack.com/guide/what-is-test-driven-development">Test Driven Development (TDD) : Approach &amp; Benefits | BrowserStack</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=514a147f07e1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Clean your code!]]></title>
            <link>https://medium.com/@anastasiaaudiw/clean-your-code-f13c8736cc2f?source=rss-f1cd82e8b764------2</link>
            <guid isPermaLink="false">https://medium.com/p/f13c8736cc2f</guid>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Anastasia Audi]]></dc:creator>
            <pubDate>Wed, 26 Oct 2022 16:51:46 GMT</pubDate>
            <atom:updated>2022-11-20T09:02:05.651Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kae_ktmaLWIN6S43ncAymw.png" /></figure><p>I guess that many of you may have heard of clean code or code smell. Well, in order to produce high-quality code and maintain it ready for fast pace development and operations, applying clean code will definitely help you with that.</p><h3>But what is the Clean Code?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*x_Vrnb1O4vlA0EFj.jpg" /><figcaption><a href="https://techcastle.com/10-ways-to-clean-up-your-computer/">https://techcastle.com/10-ways-to-clean-up-your-computer/</a></figcaption></figure><p>Clean code is easy to understand and modify by other programmers. Moreover, writing clean code is the best practice since we want it to be maintained efficiently.</p><p>Clean code is a clear, traceable, logical, and disciplined implementation of code in your program. Writing readable and reasonable code is a crucial skill every developer needs. If you have not implemented clean code as your software development practice, you might’ve noticed some problems with extensions or errors during adaptations. Clean code principle matters because it is a foundational skill that will benefit you when it’s time to refactor the code or test them.</p><h3>Here is a list of things you can do to have a clean code:</h3><h4>1 — Have SOLID principles</h4><p>Following the SOLID principles is an excellent way to ensure that your code is flexible, maintainable, and long-lasting. This principle is to help developers write clean, well-structured, and easily maintainable code. The SOLID guide consists of the following:</p><ol><li><strong>S</strong>ingle responsibility principle (SRP)</li><li><strong>O</strong>pen-closed principle (OCP)</li><li><strong>L</strong>iskov Substitution Principle (LSP)</li><li><strong>I</strong>nterface Segregation Principle (ISP)</li><li><strong>D</strong>ependency inversion Principle (DIP)</li></ol><p>You can find them through <a href="https://medium.com/r?url=https%3A%2F%2Fseverinperez.medium.com%2Fwriting-flexible-code-with-the-single-responsibility-principle-b71c4f3f883f">this source</a> to learn further about the SOLID principles.</p><h4>2 — Start writing less code</h4><p>As you write your code, you often forget the number of lines you’ve written and whether or not it’s clear. Especially if you’re busy fixing bugs or adding features, you lose focus on how clean your code should be. Therefore, you should start taking care of your code and make it as efficient as possible. A good example is avoiding lots of nested loops. Not only that it is very hard to digest and very long, but it also produces a bad time performance. You can try to simplify the code by implementing algorithms or extracting them into separate methods.</p><h4>3 — Implement good naming</h4><p>You might’ve seen some poorly named variables, classes, and functions. By implementing good naming, you’re basically contributing to writing readable code and can easily understand what it does without having to add any unnecessary comments. This will also save time for the development team because they can easily comprehend the named variable’s function.</p><h4>4 — Stop code repetition</h4><p>There’s a principle in programming that says, “Don’t Repeat Yourself” or, in short, “DRY”.That principle means that we need to avoid writing the same code repeatedly. Reducing code repetition will make your whole code cleaner. Implementing DRY will reduce code redundancy and will enhance code readability. One implementation that we can do is to create a component in our flutter project. Using reusable components can help reduce code duplication and shorten the code.</p><h4>5 — Rethink your comments</h4><p>Whenever we finish writing our program, we comment on it to remember what the program does. Despite being helpful, sometimes those comments get too much and make our code looks terrible. That’s why we need to rethink again before commenting on our code. A good code should be able to speak for itself.</p><h3>Clean Code Implementation</h3><p>Implementing a clean code strategy has helped me to write better code as a front-end developer. Since we’re working collaboratively, it is necessary to understand each other’s code. A good example is grouping our files into a good system, and we use the proper naming system for our file names, variables, methods, classes, and functions. This definitely helped us understand each function in each other’s code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/514/0*0-qI1bhm07-WTtCo" /></figure><p>Another thing, we also do not use any not necessary comments in our code because we’ve created a straightforward naming convention. This can minimize any code smells, especially for clarification comments, because it can indicate that the code is too complex.</p><h3>To conclude…</h3><p>I know that this article is far from complete, but I do encourage you guys to start caring about your code quality and implement clean code strategy to your future development projects. Please do seek further information regarding clean code, and thank you for reading this article!</p><h3>References:</h3><p><a href="https://blog.devgenius.io/your-ultimate-guide-to-clean-code-ffffccb04c0a">Your ultimate guide to clean code</a></p><p><a href="https://www.pluralsight.com/blog/software-development/10-steps-to-clean-code#:~:text=Clean%20code%20is%20a%20reader,writing%20code%20for%20computer%20consumption.">10 Steps to clean code</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f13c8736cc2f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Get to Know Usability Testing]]></title>
            <link>https://medium.com/@anastasiaaudiw/your-guide-to-usability-testing-998ff5249095?source=rss-f1cd82e8b764------2</link>
            <guid isPermaLink="false">https://medium.com/p/998ff5249095</guid>
            <category><![CDATA[process-design-thinking]]></category>
            <category><![CDATA[usability-testing]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Anastasia Audi]]></dc:creator>
            <pubDate>Wed, 26 Oct 2022 16:46:33 GMT</pubDate>
            <atom:updated>2022-11-23T13:23:27.506Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8w0vtgKo6vo_fD0d4Ehydw.png" /></figure><p>If you’re in the tech industry, you might’ve heard of user experience. The task of a UX designer is not only creating an excellent design for its users but testing them as well. Because without any testing, the designer may produce biased designs without validating them to the users. With the help of usability tests, the designer and company may receive feedback on improving their product service and resolving any existing issues to improve the user experience.</p><p>Before jumping right in, you should familiarize yourself with the design process of a UX designer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*AtTTYJVDJBjA7wv3.jpg" /><figcaption>source: interaction-design.org</figcaption></figure><p>The testing stage is located at the very last step of the design thinking process because it tests the implementation of the product, refining any problems and validating them with the users and stakeholders.What is the Usability Test?</p><blockquote>UX is a field of user research in which evaluators assess the quality of a user’s experience with an perceptions of a system — Interaction Design Foundation</blockquote><p>Usability testing is a method that evaluates the product with real people and is usually conducted before and after the product is released. The test aims to identify potential problems users may experience, assess the product’s performance, and improve the overall user experience.</p><p>It is practised by asking a fellow user to try the product by completing a list of tasks while the researcher should observe and notes the user’s interactions with the products. The main goal of this test is to understand whether the product is usable and functional enough for users to accomplish their goals.Types of Usability Testing</p><h4>1 — Moderated and Unmoderated Testing</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EJ-pRK9LYNvIHnMz.png" /><figcaption><a href="https://www.userfeel.com/blog/moderated-vs-unmoderated-user-testing">https://www.userfeel.com/blog/moderated-vs-unmoderated-user-testing</a></figcaption></figure><p>A moderated usability test consists of a moderator that will guide the user participant by facilitating the session, instructing the user to do some tasks, asking relevant questions, and providing guidance if any problems are encountered. On the other hand, user participants will be doing some of those tasks on the product application and providing feedback on their user experience.</p><p>Moderated tests can be conducted through the online or in-person sessions. If its done remotely, the moderator can invite user participant on an online call meeting and asks them to share their screen so the moderator can record and observe the participant’s actions.</p><p>Unmoderated is implemented without the presence of a moderator. This usually utilizes certain UT tools where the participants can receive the instruction of a task without anyone to help. This method can be conducted at any time and place according to the user’s preference. A good tool I’d recommend is the maze.</p><h4>2 — Quantitative and Qualitative Data</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WDx1WTW5PFbY19Os.jpg" /><figcaption><a href="https://microbiologynote.com/difference-between-quantitative-and-qualitative-data/">https://microbiologynote.com/difference-between-quantitative-and-qualitative-data/</a></figcaption></figure><p>You’re probably familiar with these two types of data. Qualitative mainly focuses on the behavioural data obtained from observational findings. There’s no number or statistics involved in the data, it can be in the form of notes of observation or participant comments. Qualitative testing collects data about behaviours and attitudes by observing how the user reacts to the product and its actions. Examples of qualitative data are product reviews, user comments, or facial expressions.</p><p>On the other hand, quantitative testing consists of statistical numbers that can be expressed in the numerical term. The data may come in metrics to provide factual proof of the user’s experience. For instance, 60% of the participants left the homepage”.</p><h3>UT Best Practices</h3><ol><li>Do not lead the participant towards an answer and action by carefully phrasing the question in a way that the user is allowed to think and answer the question as they like. This will help you to have a non-biased result analysis.</li><li>Encourage the participants to explore the product as much as they like — because you aim to understand the user’s experience while using the product and notice possible improvements.</li><li>Establish evaluation criteria — you should set up your goal and identify the success criteria of your product. These will help you analyze your results according to the success metrics you set up initially.</li><li>Be inclusive with your participants — you should include people that might have different perspectives on your product based on their experience and backgrounds. These types of people may give new insights and feedback.</li></ol><h3>Final words</h3><p>To conclude, the value of usability testing to your design process is reason enough to test your product. This step is known to have very long stages and take up quite a lot of time, but do know the test’s purpose is to receive feedback from your users to create a better one.</p><h3>References</h3><p><a href="https://maze.co/guides/usability-testing/">A beginner&#39;s guide to usability testing</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=998ff5249095" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Guide to your Git Implementation]]></title>
            <link>https://medium.com/@anastasiaaudiw/guide-to-your-git-implementation-cca357096179?source=rss-f1cd82e8b764------2</link>
            <guid isPermaLink="false">https://medium.com/p/cca357096179</guid>
            <category><![CDATA[gitlab]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[software-engineer]]></category>
            <category><![CDATA[commands]]></category>
            <dc:creator><![CDATA[Anastasia Audi]]></dc:creator>
            <pubDate>Mon, 10 Oct 2022 16:06:03 GMT</pubDate>
            <atom:updated>2022-10-10T16:06:03.228Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cZ35qcxIyg8ofiKOvFRmbA.png" /></figure><p>If you’re thinking of publishing your code on a web-based repository(GitLab or GitHub), you might’ve heard of GIT. So, I’m going to share about GIT in a nutshell because it will definitely ease your experience in saving and collaborating on writing code.</p><h3>What is Git?</h3><p>Git is open-source code management that helps us control and handles systems ranging from any project size. In addition, it is convenient for tracking changes in source code, enabling multiple developers to collaborate on a development project and containing the codes before deploying them. But how does it work?</p><h4>Impact after Git</h4><ol><li>Every developer has an entire copy of the code on their local systems, as well as the central server repository</li><li>Any changes made to the source code can be tracked by other developers</li><li>There is regular communication between each developer</li></ol><h4>But how does it work?</h4><p>As the developer, your need to start off with a code that you’re willing to push to an online web-based repository. To do this, you’ll be needing to implement Git to store information about your project’s progress. A repository consists of commits or sentences describing the developers&#39; updates on the project’s code. All this information is contained in the .git folder located in the same folder as the project. However, .git is usually hidden by default in most systems.</p><h3>Getting started with Git</h3><p>You can start by registering yourself a GitHub or GitLab account after installing Git on your computer. Next is creating the repository on your git account, you can name the repository as you like, but keep in mind that it should correspond with the goal and main idea of the project. Next is understanding the git commands:</p><h4>Git Clone</h4><p>To begin, we’ll need to clone the repository into our laptop, so we’re able to run and code on the program. You can use the command:</p><pre>git clone <a href="https://github.com/PPL-Waffar/iSaveit-flutter.git">https://github.com/PPL-Waffar/iSaveit-flutter.git</a><br>Cloning into &#39;iSaveit-flutter&#39;...<br>remote: Enumerating objects: 952, done.<br>remote: Counting objects: 100% (222/222), done.<br>remote: Compressing objects: 100% (151/151), done.<br>remote: Total 952 (delta 106), reused 129 (delta 59), pack-reused 730<br>Receiving objects: 100% (952/952), 448.33 KiB | 2.46 MiB/s, done.<br>Resolving deltas: 100% (446/446), done.<br>-----------------------------------------------------------------#Changing directory using cd<br>$ cd iSavit-flutter<br>iSaveit-flutter (main)$</pre><p>The last line indicates that you’re in the designated folder, and the terminal show something alongside the directory name, (main)</p><h4>Git branches</h4><p>The (main) indicates that we are on a branch called main, its where we’re going to combine all other contents of the branch into one finalised single branch. In a single repository, you can have as many branch as you want to include the code that’s relevant to that branch. The branches&#39; goal is to separate and track specific pieces of work. On my works, I create multiple branches to separate each feature, so the developers can concentrate on their own branch without having to wait on others’ progress. You can implement these commands to help direct you to a branch:</p><pre>git checkout -b &lt;new-branch-name&gt; #Create and checkout a new branch<br>git checkout &lt;branch-name&gt; #Switching branches <br>git reset --hard origin/&lt;branch-name&gt; #Checkout a local branch, and reset it to the remote branches last commit</pre><h4>Git Merge</h4><p>After working on each branches, next thing to do is combine the contents of two branches into one called merging. To understand the git workflow, I’m going to give a proper procedure on how to merge branches into main:</p><ol><li>Push the iSaveIt-flutter branch into origin which will produce a new branch called origin/iSaveit-flutter</li><li>Merge new branch, origin/iSaveit-flutter, into the origin/main branch</li><li>Pull the new changes from origin/main into the local main branch</li></ol><p>These steps are to help you understand better on how the branch merging process works. For instance, you’re in the main branch and interested in merging the iSaveit-flutter branch into the main. You can do this by following this command:</p><pre>(main)$ git merge iSaveit-flutter<br>Updating f5b6e2f..741822a<br>Fast-forward<br> iSaveit-flutter.txt | 1 +<br> 1 file changed, 1 insertion(+)<br> create mode 100644 iSaveit-flutter.txt</pre><p>You can check the merge progress by looking at the <strong>git log:</strong></p><pre>(main)$ git log</pre><p>After merging the two branches, next thing to do is push the changes up to origin/master:</p><pre>(main)$ git push origin main</pre><p>By this step, you have completed the merging task of iSaveit-flutter branch and pushed the results into the chosen online repository.</p><p>In addition, if you’re interested in deleting your previous branch, you can complete it with this command:</p><pre>(main)$ git branch -d iSaveit-flutter<br>Deleted branch iSaveit-flutter (was 741822a).</pre><h4>Git Pull Request</h4><p>Since Git is a workplace for collaborators, you’ll use this implementation for a collaborative project with other developers. So this git command is very helpful because it allows other developers to ask for the maintainer to review the code they’re going to merge into a project, so there won&#39;t be any conflicts surfacing. You can create a pull request on GitHub right away, or follow the instruction below for a thorough flow:</p><ol><li>Click on the “New pull request” button on the Pull requests section page in the repository</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lImc3faaleuSNEFJxRiulQ.png" /></figure><p>2. Change the Base and head branch destinations. The base branch is where changes should be applied. On the other hand. the head branch contains the code of what you would like to apply.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a-2XJY72ME3zZ_i_38L2jQ.png" /></figure><p>3. Provide a clear description for your pull request. For instance, what code is contained in the pull request, what changes or feature you added that will affect the main branch. These explanation will ease the maintainer to understand your code and decide whether or not to approve the pull request.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7WBazDurmk7NmRQY2_hTGQ.png" /></figure><h3>To finish off…</h3><p>I would like to end it by saying that implementing Git in your daily life as a developer, whether you’re a newbie or not, will definitely ease your life as a software engineer. Git is also very handy when it comes to collaborating with other developers and managing the source code before deploying the program to the public. Lastly, I would like to say that I’m no expert in this field and still a learner as well, but I do hope that this reading helps you to understand Git in some way.</p><h4>References</h4><p><a href="https://www.freecodecamp.org/news/practical-git-and-git-workflows/#how-to-merge-a-branch-in-git">How to Use Git and Git Workflows — FreeCodeCamp</a></p><p><a href="https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request">Creating a pull request — GitHub Docs</a></p><p><a href="https://medium.com/@onejohi/git-understanding-the-basics-ba004a20dacc#:~:text=Git%20is%20a%20free%20and,project&#39;s%20progress%20on%20a%20repository.">Git: Understand the basics — Onejohi</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cca357096179" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Agile Software Development]]></title>
            <link>https://medium.com/@anastasiaaudiw/understanding-agile-software-development-7a30ae865c48?source=rss-f1cd82e8b764------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a30ae865c48</guid>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[sprint]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Anastasia Audi]]></dc:creator>
            <pubDate>Sun, 09 Oct 2022 10:35:14 GMT</pubDate>
            <atom:updated>2022-10-09T10:43:34.751Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MTiboG-ihsY5d1UeSIbW5Q.png" /></figure><p>Before jumping right in, I need to explain software development briefly. Software Development is a team activity to process creating, designing, deploying and supporting software before launching a product. This process is conducted by software engineers, designers, and product managers. A famous approach that is commonly used in developing many products is Agile Software Development. So, let’s understand the term behind this methodology…</p><h3>Agile Software Development</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KHXg2Xcap92_LV51TqQECg.png" /><figcaption>Agile Development Cycle</figcaption></figure><p>Agile development is a software development framework that focuses on teamwork, collaboration, and iteration. The teams can figure out how they will complete a specific task or goal on their own or as a team since they should always apply an open-minded mindset, where they must always be open to changes in the requirements or tasks given by the product owner. A great thing about Agile is that the customer and clients are heavily involved throughout the development process, especially since the goal is to satisfy the customer’s needs by delivering valuable software.</p><h3>What are Agile Frameworks?</h3><h4>Extreme Programming (XP)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2G-d5ixvECGgxw0Zqvmd3g.png" /><figcaption>Source: extremeprogramming.org</figcaption></figure><p>XP is an agile process that is implemented to stress customer satisfaction when using the product successfully. It simultaneously emphasizes the teamwork of all members, from the managers, customers, designers, and developers. This method can improve a software project in five important ways: communication, simplicity, feedback, respect, and courage. And there are five critical steps are involved:</p><ol><li><strong>Planning</strong></li></ol><ul><li>The development team construct user stories which will then be grouped into increments</li><li>The product owner should decide on delivery dates for each increment, and the developers should be committed to it</li><li>Release a planning schedule for each member to follow</li></ul><p>2. <strong>Managing</strong></p><ul><li>Providing a healthy and open work-space for the whole development team</li><li>Set up daily stand-up meetings to discuss updates and progress from each developer</li><li>Measure the projected velocity by summing up the user stories that were finished during the iteration</li></ul><p>3. <strong>Designing</strong></p><ul><li>Implement CRC cards for designing sessions: Class, responsibilities, and Collaboration. This allows the team members to contribute to designing an efficient system.</li><li>Create a simple design that is cheaper and faster to implement</li><li>Create a spike solution to allow developers to explore potential solutions for technical design problems</li></ul><p>4. <strong>Coding</strong></p><ul><li>A well-written code that meets up with the standards</li><li>Encourage a pair programming to increase the software quality without requiring more time</li></ul><p>5. <strong>Testing</strong></p><ul><li>Every code must have its unit tests and pass all of them</li><li>The acceptance test is defined by the customer and executed to asses the users’ satisfaction</li></ul><h4>Scrum</h4><p>Scrum is a process of managing a product development team that includes many steps and requirements. In scrum, the development work is divided into several backlogs, which will be implemented into sprints. Then, scrum is assessed through short meetings to discuss the updates for each backlog and undergo demos with the whole team.</p><p><strong>There are three roles in a scrum:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DH_vAYcMDm6MSaJ9-dZmnQ.png" /><figcaption>Scrum roles</figcaption></figure><ol><li>Product owner: Define the product backlog, gathering input from customers, clients and stakeholders</li><li>Development or scrum team: developers who work together as a team to implement a backlog in each sprint</li><li>Scrum master: organize a scrum team and manages the scrum events</li></ol><p><strong>But how do scrum events conducted?</strong></p><p>There are four types of scrum meetings in a single sprint.</p><ol><li>Sprint planning usually lead by the product owner to the team members. during this meeting, they should decide on which backlog to implement from the list of product backlogs.</li><li>Daily stand-up meetings are done twice each week. The product owner should ask the developers team, “what did you do since the last scrum meeting? Do you encounter any obstacles? What will you do before the next meeting?”</li><li>Sprint review is where the developers demo their work to the product owner. They can also discuss business opportunities and decide what’s next.</li><li>A sprint retrospective is done at the very last of each sprint. They will evaluate the sprint and usually spill any concerns or challenges they find throughout the sprint.</li></ol><h3>To conclude…</h3><p>Agile software development is highly recommended for implementation because of its flexibility, collaboration and teamwork. However, keep in mind that this is only great for a fast-moving business environment that does not have a strict and critical control system since the requirements are likely to change quickly and unpredictably.</p><h3>References</h3><p>[Pressman, 2010] Pressman, Roger S. Software Engineering: A Practitioner’s Approach. New York: McGraw-Hill Higher Education, 2010.</p><p><a href="https://www.agilealliance.org/agile101/">Agile 101 — agilealliance</a></p><p><a href="http://www.extremeprogramming.org/">Extreme Programming: A gentle introduction</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a30ae865c48" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>