<?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 Indira Devi on Medium]]></title>
        <description><![CDATA[Stories by Indira Devi on Medium]]></description>
        <link>https://medium.com/@indira.devi?source=rss-6161431633e0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*sGYq_PgFcthWlW8c</url>
            <title>Stories by Indira Devi on Medium</title>
            <link>https://medium.com/@indira.devi?source=rss-6161431633e0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 18:01:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@indira.devi/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[Making Your Code Squeaky Clean]]></title>
            <link>https://medium.com/@indira.devi/making-your-code-squeaky-clean-515a127f6b4b?source=rss-6161431633e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/515a127f6b4b</guid>
            <category><![CDATA[clean-code]]></category>
            <dc:creator><![CDATA[Indira Devi]]></dc:creator>
            <pubDate>Wed, 07 Dec 2022 23:54:14 GMT</pubDate>
            <atom:updated>2022-12-07T23:54:14.484Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0Wo8f66Jr6PiRoXW44DogA.png" /><figcaption><a href="https://blog.knoldus.com/keep-your-code-clean/">https://blog.knoldus.com/keep-your-code-clean/</a></figcaption></figure><p>Clean code is code that is <strong>easy to read and understand</strong>, and that f<strong>ollows coding conventions and best practices</strong>. It is the foundation of a successful software development process and can improve the stability, readability, and maintainability of a codebase. Clean code principles are based on the idea that writing code should be a process of continual improvement, not just a means to an end.</p><h3><strong>How do we do it?</strong></h3><p>There are somethings to keep in mind when creating clean code. It is written with <strong>readability</strong> in mind, meaning that it is easy to understand and follow. It should be organized into logical blocks of code, with meaningful comments and variable names. It should also contain only the code necessary to solve the problem at hand, with no extraneous or redundant elements. Next, clean code should be written with <strong>performance</strong> in mind. It should strive to minimize the number of operations, taking into account the cost of operations in terms of time and resources. It should also be written with <strong>scalability</strong> in mind, ensuring that the code can be scaled up or down as needed.</p><p>A good principle to have, sort of a guideline is the SOLID principle:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6FpeIGLKD8zepa7z.png" /><figcaption><a href="https://morioh.com/p/6ad988739dff">https://morioh.com/p/6ad988739dff</a></figcaption></figure><p>An example of this would be, for example the S principle (Single Responsibility) which states a class should have only one responsibility.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1RNxeqBs8_5WLxPSIMJ2UA.png" /></figure><p>Here is an example of a class for One Day Intern (ODI). The InteractiveQuizAttempt class only has one responsibility, to represent an assessee’s attempt of a quiz.</p><p>Clean code should also be <strong>tested</strong> and <strong>refactored</strong> regularly. Testing is important to ensure that the code is working as expected and that any changes made do not break existing functionality. Refactoring is an important part of the process, as it can help make the code more efficient and easier to maintain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mq67hQ7nOm6qXEzTAQnZEw.png" /></figure><p>When you take a look at ODI’s GitHub, you will see a lot of [REFACTOR] commit messages, as we use software such as Codacy and SonarCloud to do the quality check, making sure our code is at the top of their performance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oPjcBuwJB56C52MNMAFoeA.png" /></figure><p>Here’s an example of a failed quality check, which we have to refactor before we can continue with our pull request.</p><h3><strong>How does clean code make development easier?</strong></h3><p>Clean code principles can help developers create better code and make software development more efficient. By following these principles, developers can ensure that their code is more reliable and easier to maintain, resulting in fewer errors, quicker development cycles, and better overall software.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=515a127f6b4b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[DevOps & Maintainability]]></title>
            <link>https://medium.com/@indira.devi/devops-maintainability-46d0b57a4c35?source=rss-6161431633e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/46d0b57a4c35</guid>
            <category><![CDATA[maintainability]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Indira Devi]]></dc:creator>
            <pubDate>Wed, 07 Dec 2022 23:38:00 GMT</pubDate>
            <atom:updated>2022-12-07T23:38:00.318Z</atom:updated>
            <content:encoded><![CDATA[<p>Software maintenance and development is a crucial part of any business. It’s essential to keep your software up-to-date and in top condition if you want to remain competitive in the market. Software maintenance and development is a process that involves making sure that the software is functioning properly and that the software is being updated regularly. This includes bug fixes, new features, and performance enhancements.</p><p>Software maintenance and development can be done in-house or outsourced to an external provider. Depending on the complexity of the software and the size of your business, you may find that one of these options is more cost effective.</p><h3>DevOps Lifecycle</h3><p>When it comes to software maintenance and development, there are a few key steps to follow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zvaIHvd7rcgaun7HO0uFQQ.png" /><figcaption>source: <a href="https://medium.com/taptuit/the-eight-phases-of-a-devops-pipeline-fda53ec9bba">https://medium.com/taptuit/the-eight-phases-of-a-devops-pipeline-fda53ec9bba</a></figcaption></figure><ol><li><strong>Monitor the software <br></strong>Before you can begin any maintenance or development work, you need to be able to monitor the current state of the software. This will allow you to identify any potential issues before they become serious problems.</li><li><strong>Identify potential issues<br></strong>You need to be able to identify potential issues and be prepared to address them accordingly. This could involve making changes to the code, changing the hardware, or even bringing in an external expert to help.</li><li><strong>Develop a plan </strong><br>Once you have identified the issues, you need to come up with a plan of action. This plan should include the steps you need to take in order to address the issues and ensure the software is functioning properly.</li><li><strong>Implement the plan</strong><br>Once you have developed a plan, it’s time to start making the necessary changes. This could involve making changes to the code, updating the hardware, or bringing in an external expert to help.</li><li><strong>Test the changes <br></strong>Once the changes have been made, you need to test them to ensure that they are functioning properly. This is critical to ensure that the software is functioning as expected.</li><li><strong>Finalize the changes</strong><br>Once the changes have been made and tested, you need to finalize them. This could involve making any necessary changes to the documentation or making sure that the software is properly released.</li></ol><p>Software maintenance and development is a critical part of any business. It’s important to ensure that your software is functioning properly and that it is being updated regularly.</p><h3><strong>Error Handling</strong></h3><p>The response and recovery procedures from error conditions present in a software application are referred to as error handling. In other words, it is the process of anticipating, detecting, and resolving application, programming, or communication errors. Error handling contributes to the normal flow of program execution. When it comes to error-handling techniques, many applications face numerous design challenges.</p><p>How do we actually handle errors? There are two ways:</p><p>First, <strong>Error Prevention</strong>, we can limit the user’s actions into not making that many errors by giving them a message.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lx1cFm8O6I01YymiVjpzRw.png" /></figure><p>The example is a snipper of One Day Intern for validating an assessment tool request. This limits the user’s actions and prevents an error from being made by checking several things from the request. If the request is invalid, for example because the tool doesn’t exist, the system will output a message for the user.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*RPCwqt5LzaHSflScMCmj4A.png" /></figure><p>Next a the visualization of error prevention is when an assessor tries to create a question, when they want to continue or move from this page, they have to fill out all the requuired fields first. Since the Points field hasn’t been filled, the systems displays an error message.</p><p>Sencodly, we can do <strong>Error Recovery</strong>. This is when we let the users undo or cancel an action they did.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7yAWecddGznpn9BrF1a17Q.png" /></figure><p>An example would be from ODI’s quiz maker, in every step of the process the assessor can choose to cancel their actions. In the pop up asking the users to confirm their actions, they can even cancel the cancellation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=46d0b57a4c35" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Gentle Introduction to SonarQube’s Many Sections (and How to Use Them)]]></title>
            <link>https://medium.com/@indira.devi/a-gentle-introduction-to-sonarqubes-many-sections-and-how-to-use-them-615dc370d4da?source=rss-6161431633e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/615dc370d4da</guid>
            <dc:creator><![CDATA[Indira Devi]]></dc:creator>
            <pubDate>Thu, 24 Nov 2022 02:32:38 GMT</pubDate>
            <atom:updated>2022-11-24T02:32:38.969Z</atom:updated>
            <content:encoded><![CDATA[<p>The process of ensuring that a software product satisfies and complies with the quality criteria that have been set and defined by an organisation is referred to as “software quality assurance,” or SQA for short. This process is continuous. SQA is a collection of actions that ensures all participants in a project have properly executed all of the project’s procedures and processes.</p><p>The process of quality assurance testing often follows a cycle that is referred to as the PDCA cycle. <strong><em>Plan</em></strong>, this phase sets project goals and methods. First, goals and how to accomplish them are discussed. <strong><em>Do</em></strong>, the quality assurance tester will regularly monitor and go through each change and progress while the creation and development process is being carried out. <strong><em>Check</em></strong>, this stage involves monitoring process implementation and determining whether they satisfy goals. <strong><em>Act</em></strong> in this phase after evaluation, adjustments and quality assurance recommendations are made. These actions are performed on your software products on a regular basis in order to guarantee that the structure of the processes is being assessed and improved.</p><p>Software release procedures include quality assurance. Before deploying a program or tool, a software company must test it. The product manager considers quality assurance and operation final development stages. Ensure product quality to build customer loyalty. Software is tricky because it requires checking many aspects. Your software must meet customer expectations.</p><p>The Code Quality Assurance tool known as SonarQube gathers and analyses your project’s source code, and then generates reports about the code quality of your overall activity. It integrates tools for static and dynamic analysis and makes it possible to assess quality in an ongoing manner over a period of time. SonarQube analyses and examines every aspect of the design, from the most insignificant stylistic decisions to the most severe errors. In addition, it makes sure the code is reliable, makes the application more secure, and reduces technical debt by keeping the code base clean and easy to maintain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6JjhPJ0Jbb9iw20cHh75TQ.png" /></figure><p>Here is the first thing we see when we open up the tool, a summary of all the aspects that they grade. The above example is a view that should be strived for, even though it can be improved, as the given grade on the top four categories is A. However, before we get to this point we need to see how SonarQube catches errors that bring our grade down. Let’s go through them.</p><p><strong>Reliability</strong>. Developers aren’t unfamiliar with the term “Bug”, and they know that it’s something that needs to be rid of to ensure that the system works smoothly. Essentially a bug is defined by SonarQube to be “A coding error that will break your code and needs to be fixed immediately.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z12ECoKDGiZpnqieB6BlDA.png" /></figure><p>From the example above, SonarQube provides a very detailed list on the apparent bugs that are present in your code. The sidebar also has a filter list on different types of Severity, Status, etc. to better get a grasp on the bugs. Each bug that is listed is given a concise information on the <strong>5WH1</strong> to fix that bug:<br><strong>What</strong>: describes the bug<br><strong>Where</strong>: provides the path and the file in which the bug is present<br><strong>Why</strong>: ‘<em>Why is this an issue’</em> will open a pop up of an explanation on why it’s a bug<br><strong>Who</strong>: SonarQube actually provides an <strong>asignee feature</strong> such that a member of the team can be selected to fix that bug<br>How: ‘<em>Why is this an issue</em>’ will open a pop up of an explanation on why it’s a bug AND a <strong>suggestion</strong> on how to fix it</p><p><strong>Maintainability</strong>. Code smells don’t inherently cause errors in the code, but it affects how the code will be maintained in the future, and if it’s unmaintainable it will end up having bugs. Code smells are parts of code that are confusing to understand, graded using industry standards.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ORyAEP3gYPl7AtVmtAUE4g.png" /></figure><p>Code smells have a similar view to bugs and we can see from the picture above an example on the very helpful ‘<em>Why is this an issue?</em>’ feature.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vs2WQH5zsCVvjPgM8v5hjQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iNBK_Bqaz0LiLk6rG8XaxQ.png" /></figure><p><strong>Security</strong>. Developers need to make sure that the code they put out is secure and doesn’t have any vulnerabilities—something that can be exploited by hackers. SonarQube does an amazing job in detecting any vulnerabilities that the system has. Another similar aspect is the <strong>Security Review</strong>—Security-sensitive code that requires <em>manual</em> review to assess whether or not a vulnerability exists.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*kum3JcxhL9lv1Rx2.png" /></figure><p>So, the developers are given tasks to review the hotspots and are given feedback and the basis on why they are considered hotspots.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Baido3Qvy1BNX0AUkxSQwQ.png" /></figure><p>Lastly, <strong>Coverage </strong>(the percentage of lines of code covered by tests) and <strong>Duplications </strong>(identical lines of code).</p><p>That is all from what SonarQube’s sections do, I hope it provides a clearer understanding and maybe even help how you effectively use it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=615dc370d4da" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mocks in Testing]]></title>
            <link>https://medium.com/@indira.devi/mocks-in-testing-db6e78b2ce91?source=rss-6161431633e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/db6e78b2ce91</guid>
            <dc:creator><![CDATA[Indira Devi]]></dc:creator>
            <pubDate>Thu, 24 Nov 2022 02:22:25 GMT</pubDate>
            <atom:updated>2022-11-24T02:22:25.253Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Mocking</strong> is primarily used in <strong>unit testing</strong>. It is essentially creating a fake version of an external or internal service that can stand in for the real one, helping your tests run more quickly and more reliably. When your implementation interacts with an object’s properties, rather than its function or behavior, a mock can be used. It’s different from <strong>stubbing</strong>, as a stub only mocks the <strong>behavior</strong>, but not the entire object.</p><p>The primary purpose of mocking in automated testing is to isolate the “code under test” (CUT). In addition, when your code uses external dependencies like system calls, or accessing a database mocking can be a great lifesaver. Another benefit is that you can reproduce complex scenarios more easily. For instance, it is much easier to test the many error responses you might get from the filesystem than to actually create the condition. Say that you only wanted to delete corrupt files. Writing a corrupt file can be difficult programmatically, but returning the error code associated with a corrupt file is a matter of just changing what a stub returns.</p><p>Now how do we actually mock an object? Here is a function that I tested for One Day Intern, the feature to create an interactive quiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KSL5PfmqsZJOoRKCUTZOEg.png" /></figure><p>The function under test requires an output from the save interactive quiz to database function, which is used to invoke the various other functions. As a result, the return value must be assigned to one of the possible values, which is an instance of an interactive quiz. As a result, we must define a mock for each of the dependency functions in the test. This is possible in Python by using the unit test mock patch object decorator, which inserts the mock object as an argument to the test function while it is running, as shown below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VYjAB5aqVi_EKIuCKqWCug.png" /></figure><p>After defining the mock objects, we must define the expected behavior. The mocked object performs no computations and only returns the value that was previously set. As a result, we must specify the function’s return value or behavior, which will be passed on to the caller function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cc72YcrDz0D7tcvWGfPbpg.png" /></figure><p>Next we call the save_interactive_quiz_to_database function:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UIPjVcal_YBkZkyHhp9BXQ.png" /></figure><p>And lastly we assert that the created InteractiveQuiz object is as expected:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cOVook29ZQlZKJNroAAdiw.png" /></figure><p>So should all tests be done like this? No, while mocking is a great way to do unit tests, mocking is a way to replace a dependency in a unit under test with a stand-in for that dependency. In terms of functional or integration tests, we must evaluate the overall correctness of the software and the execution.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db6e78b2ce91" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Analyzing Nielsen’s 10 Usability Heuristics: One Day Intern]]></title>
            <link>https://medium.com/@indira.devi/analyzing-nielsens-10-usability-heuristics-one-day-intern-f72f367cf68c?source=rss-6161431633e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/f72f367cf68c</guid>
            <category><![CDATA[interface-design]]></category>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[ui]]></category>
            <dc:creator><![CDATA[Indira Devi]]></dc:creator>
            <pubDate>Mon, 21 Nov 2022 23:16:19 GMT</pubDate>
            <atom:updated>2022-11-21T23:16:19.455Z</atom:updated>
            <content:encoded><![CDATA[<p>User interface design, often known as “UI design,” is the process that is used by designers to construct user interfaces in software or other digital devices, with an emphasis on appearance or style. The goal of interface design is to provide applications that people like using and find simple to use. The term “user interface design” refers to the creation of graphical user interfaces as well as other forms, such as voice-controlled interfaces.</p><p>The graphical interfaces of mobile applications, websites, and other devices are designed by user interface designers. These are the aspects with which a user engages in direct interaction. Unlike user experience, or UX, which can be applied to nearly any product or service, user interface, or UI, can only be applied to digital products. A user interface designer’s goal is to create websites and applications that are not only aesthetically pleasing but also simple to use.</p><p>Nielsen’s heuristics are general principles, not usability requirements. Heuristics are guidelines for creating accessible, user-friendly, and intuitive digital products. They built these heuristics from observation and experience. There are 10 Nielsen heuristics:</p><p><strong>Visibility of system status</strong></p><p>The design should always keep users informed about what is going on by providing relevant feedback within a reasonable length of time. This should be done throughout the design process.</p><figure><img alt="User Interface Design of One Day Intern Assessment Category" src="https://cdn-images-1.medium.com/max/1024/1*MWjb5l7RlsWuKNUlQM0_7g.png" /><figcaption>User Interface Design of One Day Intern Assessment Category</figcaption></figure><p>During the assessment tool creation process, the users will see a side bar that describes what stage they are at.</p><p><strong>Match between system and the real world</strong></p><p>The design needs to communicate well with the users. Instead of using internal jargon, use words, ideas, and concepts that are already recognizable to the user. Follow the standards of the real world and arrange the material such that it appears in a logical and natural manner.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*odTL0W-CBXKPZZNCmeOUzQ.png" /></figure><p>In the quiz reviewing stage, the interface design is made to look similar to a physical test in the real world in both text and multiple choice format.</p><p><strong>User control and freedom</strong></p><p>Users often carry out acts accidentally. They require a clearly labeled “emergency exit” so that they can abandon the undesirable activity without having to go through a lengthy procedure.</p><figure><img alt="User Interface Design of One Day Intern Assessment Category" src="https://cdn-images-1.medium.com/max/1024/1*MWjb5l7RlsWuKNUlQM0_7g.png" /><figcaption>User Interface Design of One Day Intern Assessment Category</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*fDQK-NYKOkAm_jzYGddBjQ.png" /><figcaption>User Interface Design of One Day Intern to Create Assignment</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eA-CUeqLMHNd8DaRaGayVA.png" /><figcaption>User Interface Design of One Day Intern to Create Interactive Quiz</figcaption></figure><p>ODI’s Assessment Tool feature has a cancel button at every step of the process, which provides an “emergency exit”</p><p><strong>Consistency and standards</strong></p><p>It is not appropriate for users to be required to consider if various words, situations, or activities mean the same thing. Always follow the platform’s and the industry’s standards.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*9aHtR5q8-sboKq7VsxE_cw.png" /></figure><p>ODI’s login page complies with the industry standard and doesn’t add any unnecessary jargon or new words that the user has to learn, making the page intuitive. In addition, it provides an alternative choice of login method which is another industry standard.</p><p><strong>Error prevention</strong></p><p>It is essential to have clear and helpful error messages, but the most effective systems actively work to prevent errors from happening in the first place. Either get rid of conditions that are prone to mistakes, or check for them and give users the opportunity to confirm their decision before they take action.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*FrMRgYgzQOg9iYzfMnzD9w.png" /></figure><p>When a user wants to cancel the Interactive Quiz building process, they are given a confirmation question which provides a clear message on the consequences of their action so that the user can confirm their decision before they take action.</p><p><strong>Recognition rather than recall</strong></p><p>Users shouldn’t have to remember all the functionality of the system. Leave small reminders to help users navigate your designs. For example, menu items should be easily visible or accessible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-cuxOzgCIt_djflgUaOdMQ.png" /></figure><p>Here we can see a list of all the assessments that an assessor is associated with. The navigation bar is visible and states all the menu items or pages that the user can navigate to. The view also gives the Assessor an option to view all the active assessments or the archived ones, as well as a button such that they can create an assessment event.</p><p><strong>Flexibility and efficiency of use</strong></p><p>New users require additional details. They gain experience when they use a product. Allowing them to create keyboard shortcuts is an excellent practice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*prd3v8WNo3EGgD-kaHU40Q.png" /></figure><p>Since an assessee has their own mock desktop, it functions with all the shortcuts that a normal desktop has: minimizing windows, exiting out of windows, etc.</p><p>Here we can see the process of an Interactive Quiz attempt where the user can open a sidebar so that they can select which number they want to go to quickly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WRcl7mgZhNeokn0MsGDBOw.png" /></figure><p><strong>Aesthetic and minimalist design</strong></p><p>It is essential that, as a designer, you not prioritize aesthetics above functionality. As a result, it is important to design interactions that only provide necessary information. It’s important to keep unused graphic components away since they may easily overwhelm and distract users.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mgc980duR3RxhREFfeo2PQ.png" /></figure><p>ODI’s interface design has a distinct and consistent color palette, and utilizes simple but distinguishable icons to further help the user understand the many features available.</p><p><strong>Help users recognize, diagnose, and recover from errors</strong></p><p>Your designs should help users detect and fix issues. Clear, code-free error messages are needed. Describe the issue and provide a solution.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*McDaV21RUWodARzqTiIJjg.png" /></figure><p><strong>Help and documentation</strong></p><p>It would be ideal if the system didn’t need any more explanation of any kind. On the other hand, it may be necessary to provide documentation to users in order to assist them in understanding how to carry out their tasks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9vqTY6o22VdataI3J713Dg.png" /></figure><p>One day intern provides explanation of features and small demos that help users visualize what they can do. In addition the website provides an email for the users to contact when they have enquiries.</p><p>Those are just some of the features that apply the 10 heuristics, which hopefully provide some clarity on how to implement them in your UI design. Cheers!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f72f367cf68c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Importance of Code Reviews]]></title>
            <link>https://medium.com/@indira.devi/importance-of-code-reviews-2f6eef37e060?source=rss-6161431633e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/2f6eef37e060</guid>
            <category><![CDATA[code-review]]></category>
            <dc:creator><![CDATA[Indira Devi]]></dc:creator>
            <pubDate>Thu, 10 Nov 2022 01:46:58 GMT</pubDate>
            <atom:updated>2022-11-10T01:46:58.853Z</atom:updated>
            <content:encoded><![CDATA[<p>Code reviews are methodical assessments of code that are intended to detect bugs, improve code quality, and assist developers in learning the source code. Creating a strong code review process, or using version control, lays the groundwork for continuous improvement and keeps unstable code from being shipped to customers.</p><p>Why is code reviews important for developers? First of all, it improves the code quality, by detecting any issues, before it got out of control. It also ensures the consistency standard. It makes code more readable for testers to understand.</p><p>Below is an example of a code review that clarifies code made by a team member:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Pu09b-Qzqkdz-94EMnHyGA.png" /></figure><p><strong>Things not to do:</strong></p><p>Come unprepared.</p><p>Quibble over details.</p><p>Make it personal.</p><p>Ridicule the algorithms.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2f6eef37e060" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When We Should Apply Scrum]]></title>
            <link>https://medium.com/@indira.devi/when-we-should-apply-scrum-93531ff65469?source=rss-6161431633e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/93531ff65469</guid>
            <category><![CDATA[scrum]]></category>
            <dc:creator><![CDATA[Indira Devi]]></dc:creator>
            <pubDate>Thu, 10 Nov 2022 01:35:59 GMT</pubDate>
            <atom:updated>2022-11-10T01:35:59.682Z</atom:updated>
            <content:encoded><![CDATA[<p>Scrum is a project management framework that emphasizes collaboration, accountability, and iterative progress toward a well-defined goal. Scrum, which was originally designed for software development, is now used by organizations and project managers across all disciplines. The methodology works well for smaller teams tackling projects with changing deliverables, unknown solutions, and frequent client or end-user interaction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Se5CEYFeE7ou_9PFpHI8OQ.png" /></figure><p>To begin using the Scrum methodology, three key roles must be assigned: product owner, scrum master, and development team. The role of the product owner is to guide your colleague and maintain communication between the team. To be a good project manager, you need to be able to answer all the questions given about the project and provide a clear understanding throughout the life of the project.</p><p>The difference between a scrum master and a project manager is that a scrum master does not give detailed instructions to their team. The rest of the team is called the development team, which includes programmers, designers, writers, and platform testers, also known as quality assurance experts. They are tasked with carrying out the product deliverables.</p><p>There are six different types of scrum events. The first is the daily scrum, which is a short event where the team reviews the work that has been accomplished on the previous day and what will be accomplished in the next 24 hours. The second is the sprint, in which work must be completed in 30 days or less. The third meeting is the sprint planning meeting, during which the team discusses the importance of producing at least one increment — usable software — when setting goals. The fourth is the sprint review, where the team shows off the increment. The final one is a sprint retrospective, which is a meeting held after a sprint concludes. In this meeting, the team reflects on the process, and team-building activities may also be offered.</p><p>Scrum helps you have a lot of unique advantages for your team. Due to the sprint retrospective, we can get better-quality products because of the continuous improvement and feedback in each meeting. Scrum also helps your team communicate more so they can meet deadlines and solve problems together. This strategy emphasizes a predictable, sustainable delivery time and continuous feedback, which allows the team to eliminate risk early and often and many more, such as adaptability, which produces more flexibility and efficiency.</p><p>While there are numerous benefits to using Scrum, there must be some drawbacks. For example, if any team members are absent, it can disrupt the work flow for project development, and larger teams may have difficulty implementing Scrum elements. All team members must be really committed to doing this project, otherwise, it will cause a roadblock.</p><p>So when do we need to apply Scum to our project? It is needed when you have a complex project, any complex project can experience the benefit of scrum, due to the daily meetings, each member can review their own work, and discuss what will they do next. It can easily adpet to sudden changes, and can create a product that go along with emerging business objective. Unless you have a small project. This means that if your task isn’t complex or can’t be broken down and planned in short iterations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=93531ff65469" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Benefits of Test Driven Development]]></title>
            <link>https://medium.com/@indira.devi/benefits-of-test-driven-development-4fca638d756a?source=rss-6161431633e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/4fca638d756a</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[django-rest-framework]]></category>
            <category><![CDATA[test-driven-development]]></category>
            <dc:creator><![CDATA[Indira Devi]]></dc:creator>
            <pubDate>Tue, 01 Nov 2022 00:02:05 GMT</pubDate>
            <atom:updated>2022-11-01T00:02:05.962Z</atom:updated>
            <content:encoded><![CDATA[<p>Before we get going, we must first know what Test Driven Development is. TDD, also known as Test-Driven Design, is a software development methodology that combines unit testing, programming, and source code refactoring.It was presented as part of the Agile software development process as part of a wider software design paradigm known as Extreme Programming (XP).</p><p>This method is the process of converting software requirements to test cases prior to the completion of software development. The program is then tested against all test cases to track its development. This leads to some benefits for developers, who can focus on a single feature at a time without moving on to the next one until the corresponding unit test passes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*078GhwVTD1sbcHng.png" /></figure><p>When code is written in such iterations, the code quality improves significantly, making it simpler to find bugs and reuse the code. It automatically creates cleaner, more legible, and manageable code. Focusing on smaller, more digestible code chunks demands less work from developers and makes test requirements easier to meet.</p><p>Adoption of TDD is critical for the success of your Scrum teams, and thus for your success as a Scrum Master.It may help Scrum processes in three ways. First, given the ability to absorb changes to the code on a continuous basis, You want the code to be adaptable so that updates may be approved on a regular basis to improve the existing code or to accommodate new changes based on feedback from the product owner or stakeholders.</p><p>Secondly, in developing a program, failure happens sooner or later. With TDD, you can start with failed tests, make them work as you go, and ensure they won’t fail again because of unexpected changes. Lastly, it allows you to reduce the creation of technical debt.</p><p>If developers are unable to absorb changes soon enough, you will run out of time during the sprint to make additional changes. Pushing essential changes out of sprints and, eventually, releases creates technical debt in the form of future modifications and re-work, which is not a desirable conclusion for any Scrum Master. Having a framework in place to allow fast modifications prevents the accumulation of technical debt.</p><p>After all the benefits of using TDD, there must be a downside. Well, first of all, by using this method, it slows down the work flow for developers. If you are short on time and need to launch your product early, this method may not be the right choice, because the developers will be busy making all the tests first.</p><p>This method is also challenging to maintain. When changes are made to a product, the tests must be changed to adapt to the new requirements. You’ll have to re-write the code again to fit the new test. It is also not an easy method to apply. This requires skill, persistence, and discipline.</p><p>Is it worth it? The concept of “test cases first” has numerous benefits. This process assures consistent quality even when the code is regularly improved and modified in a variety of ways. However, if you are short on time and short on money, this may not be the right method for you due to the time it will take if there are any changes made to your product.</p><p>Below is an example of TDD implementation, as shown from a pull request in One Day Intern repository:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z-DfKbQeon-eokpGLIEYHQ.png" /></figure><p>From the commit messages, we can see that there are several [TAGS] used. [RED] means that this commit adds the failing tests:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WRnuylE-JFl0RhyDE-vcRg.png" /></figure><p>Whereas [GREEN] means that we implemented the code that makes the tests pass:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fXAy_pRNhlxM66e3yqTr9Q.png" /></figure><p>Lastly [REFACTOR] means that we refactored the implemented code based the suggestions on Codacy or SonarCloud.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AhFKSTSSkjzyvMP6AmUK8w.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4fca638d756a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using SonarCloud vs. Codacy for Refactoring]]></title>
            <link>https://medium.com/@indira.devi/using-sonarcloud-vs-codacy-for-refactoring-1162df5ae7fe?source=rss-6161431633e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/1162df5ae7fe</guid>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[sonarcloud]]></category>
            <category><![CDATA[codacy]]></category>
            <dc:creator><![CDATA[Indira Devi]]></dc:creator>
            <pubDate>Mon, 10 Oct 2022 21:13:24 GMT</pubDate>
            <atom:updated>2022-10-10T21:13:24.769Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Refactoring</strong> is a very important process during programming. This is why tools such as <strong>SonarCloud</strong> and <strong>Codacy</strong> have been a big help in the refactoring process during the development of ODI.</p><p><strong>But first, what <em>is</em> refactoring?</strong></p><p>As per Martin Fowler’s book, <strong>“Refactoring is the process of changing a software system in such a way that it does not alter the<br>external behavior of the code yet improves its internal structure.”</strong> (p. 9). In other words, refactoring strives to change dirty code into cleaner code, to minimize the chances of bugs.</p><p>Having clean code helps other people to understand our code better, promotes maintainability, and favors the development of reusable design components.</p><p>In this article, I’d like to show the differences in usage of SonarCloud and Codacy during my development process. In the GitHub repository, when we create a pull request, we can view the results of SonarCloud and Codacy’s analysis of our code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*BsVp-gyRE25Rb0ZgQQrnCQ.png" /><figcaption>Checks ran after creating pull request</figcaption></figure><p>The main difference that is apparent is when we view both tools in the checks. Codacy displays brief statistics on how many issues, duplicated data, and coverage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d3BsuEXVf5xCbq0PIfrv4A.png" /><figcaption>Codacy view when opening checks</figcaption></figure><p>Whereas SonarCloud provides a more thorough dashboard, such as checking whether or not there has been a security hotspots. SonarCloud also provides “grading” in the evaluation, below we can see that the problems in the code are close to none, which gives us the rating of A.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pbAKOq1VCgV9G4Uh74jzZQ.png" /><figcaption>SonarCloud view when review checks</figcaption></figure><p><strong>Refactoring with SonarCloud, we can see that we have a code smell.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dftmszWc2H2Juom12XeG-g.png" /><figcaption>Example of Code Smell in SonarCloud</figcaption></figure><p>SonarCloud also provides an explanation to our code smell. Here, we can see that our code smell is a <strong>duplicate code/string literal</strong> code smell.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j00C1Z3IYgoJWAgZiRRnyg.png" /><figcaption>SonarCloud’s explanation on the code smell.</figcaption></figure><p>The problem with duplicate code, especially duplicate string literals, is that if we have to change for instance ‘Dummy company description’ into ‘Real company description’ we need to update all occurrences and that action would be prone to error. Therefore, we can create a constant such as DUMMY_COMPANY_DESC = ‘Dummy company description’.</p><p>In comparison, this is how Codacy brings attention to a code smell, we can see that it takes notice of an unused import. This is a <strong>dead code</strong>, and therefore the best action to take is to delete the lines.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SYTlekETTVlAHj8Sd7HC-A.png" /></figure><p>After going through all the code smells in both SonarCloud and Codacy and refactoring the code, the checks should look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*Vtj-J-Hui29apKA8UtAy9A.png" /></figure><p>So there we go, we did refactoring by utilizing two different tools! I have a slight preference to the SonarCloud analysis as it has a feature of explaining the code smell and what to do to fix it. But overall, both tools are great helpers when we want to strive for having better and cleaner code.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1162df5ae7fe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Creating a Design System with Figma]]></title>
            <link>https://medium.com/@indira.devi/creating-a-design-system-with-figma-423d93203fe3?source=rss-6161431633e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/423d93203fe3</guid>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[figma-tutorial]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Indira Devi]]></dc:creator>
            <pubDate>Mon, 10 Oct 2022 20:23:26 GMT</pubDate>
            <atom:updated>2022-10-10T20:23:26.702Z</atom:updated>
            <content:encoded><![CDATA[<p>A design system involves all of the pieces in your final app. These elements should be neatly arranged into styles and components that are referenced in a single source within a separate page. This document should be simple for anybody on your team to update.</p><p>ODI uses Figma as its main tool in UI/UX design, and this includes the entire design system. With Figma, integrating the design system with the entire design process becomes much easier, as all we need to do is to utilize the <em>Styles</em> feature.</p><p>To first create a design system, we needed to decide on the color palette as well as the font we sought to use. After some deliberation, we picked a combination of blue-purple-pink for our color palette, and to use the Inter font.</p><p>For the documentation of our design system, we used a template to write down the important aspects and the description of the styles used, as seen below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NVhAsFco4vgdsFD7Xf3lMw.png" /><figcaption>Color Style System</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aYx0X-kG-RbdU4XUWO475g.png" /><figcaption>Typography Style System</figcaption></figure><p>Next, we set the accent colors, as well as their different light and dark values that is going to be used. Here, we name the accent color components using gemstones:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/424/1*HkTSj35rT8ML7rcyViUJMg.png" /><figcaption>ODI accent colors</figcaption></figure><p>To describe our colorways, we insert the light and dark variations, opacity, and hex codes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/524/1*2f4g5dRXGlx6IBWId1spMA.png" /><figcaption>Further elaboration on Amethyst accent color</figcaption></figure><p>Here, we also describe the typography used in the design system, using the same table format. It states the type of typography—in this case the typography is used for headings, the font name, and what language.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K8s2DEYJM23yr_PkGOMmLg.png" /><figcaption>Heading typography</figcaption></figure><p>Finally, the integration of the design system with Figma. The example used is when we want to add a new color component—or in Figma terms, a new <em>color style</em>. We do so by clicking the plus sign and filling out the new name of the color style.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/1*RoIFmOU5QvYKSnthjD_aQQ.png" /><figcaption>Button to add new color style</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/786/1*nJmgAT2HQPYcP-I1aRQR7Q.png" /><figcaption>Input new color style name to create a new style</figcaption></figure><p>Which will result in a library of our color styles, as seen below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/396/1*SyMAcdZ-hmaOYx9dKeAcvw.png" /></figure><p>To create a typography style, the process is done in the same way. Now, we can access our created color styles to be used again and again in different parts of our website, which ensures consistency in our design in terms of colors and fonts.</p><p>With Figma, creating a design system is very intuitive and provides a great style library so that we can access the styles throughout different files in our Figma project.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=423d93203fe3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>