<?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 Sigute on Medium]]></title>
        <description><![CDATA[Stories by Sigute on Medium]]></description>
        <link>https://medium.com/@sigute?source=rss-de2af152264e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*3ZgTSZ-45Kkj9Xb0jjeAvw.jpeg</url>
            <title>Stories by Sigute on Medium</title>
            <link>https://medium.com/@sigute?source=rss-de2af152264e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:52:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sigute/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[Accessible Text Scaling for Android]]></title>
            <link>https://sigute.medium.com/accessible-text-scaling-for-android-6a62e0b14006?source=rss-de2af152264e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6a62e0b14006</guid>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Sigute]]></dc:creator>
            <pubDate>Thu, 29 Apr 2021 10:27:14 GMT</pubDate>
            <atom:updated>2021-04-29T10:27:14.854Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QRq7QvcBsvmp_sNHzQXTBw.jpeg" /><figcaption>Notebook and pens, photo from <a href="https://www.pexels.com/photo/pencils-and-notebook-on-wooden-table-6368904/">Skylar Kang</a></figcaption></figure><p>Do you ever open the app and cannot read the full text because it’s cut off in some way? This scenario became frequent to me once I increased the font size on my phone. Technology agency from the Netherlands, Q42, carried out <a href="https://accessibility.q42.nl/">extensive research</a> on 1.5 million iOS users and found that as many as 33% of people change the text size on their phone, and increasing text size is more common than making the text size smaller (20% increasing vs 13% decreasing). With such a large percentage, it is reasonable to assume that Android users likely also change these settings in similar frequency.</p><p>That is a big group of people, which makes it really important to consider how this setting will be supported when developing and testing your apps.</p><h3>Common issues and solutions</h3><p>I have been using various apps on my phone with non-default text and density settings. Reducing font size rarely causes any issues. However, even slightly larger than the default font size often means that a lot of issues appear. The following problems are the most common and often easily fixed.</p><h3>1. Text does not scale</h3><p>In some apps, after changing the font size, the text does not scale up at all. This is the number one issue on the list. While the layout is displayed correctly and text is visible, the user is not able to gain any benefit from the device setting and, as such, will struggle with reading the text.</p><p>Most of the time this is caused by using dp for text sizing instead of sp. dp, density-independent pixels, are used for displaying consistently sized user interface across any screen size. sp, scalable pixels, have the same default value as dp. However, sp changes with the user&#39;s font preference and dp does not. This means sp should be used for text elements so the size of the text will increase or decrease with the device setting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/0*-lS2eMHmpzm7JW6x.jpeg" /><figcaption>Screenshot shows text in sp and dp, when device font size is increased, only sp text is scaling up</figcaption></figure><p>In this screenshot, you can see how the text defined in dp remains the same size regardless of the user&#39;s font preference.</p><p>In other cases, the text does not scale because it is part of the image, instead of TextView. Providing content description is important for these scenarios, however just providing content description is not enough for an accessible solution. Not every user with vision issues is using Talkback: a better approach is using TextView over the image, as then the text size can still be increased.</p><p>Lastly, <a href="https://developer.android.com/guide/topics/ui/look-and-feel/autosizing-textview">autosizing TextViews</a> can also cause the issue of the text not scaling in an expected way. This solution ensures that the text fits inside the view nicely and layouts do not break, but this doesn’t always provide a benefit if the user is not able to easily read the text at that size. The limits need to be set carefully and testing with different font and density combinations will help to spot issues when using autosizing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/0*180Q5mLb7R1foPsl.png" /><figcaption>Image shows autosizing and not autosizing text views with different font sizes, neither having ideal behavior</figcaption></figure><p>In the screenshot, the top TextViews do not use autosizing, meaning the text does not fit as it grows longer and the font size is increased. With autosizing, the issue appears to be fixed, as all the text is visible. However, it is not a full solution, as while the text is now visible it is very small. In this case there is no easy fix in the code, and the design should be reimagined to support longer text better.</p><h3>2. Text is cut off</h3><p>In this scenario the text is cut-off in some way. Often half a line or the end of the text is missing. This usually indicates an issue with the layout constraints.</p><p>To resolve this, prefer wrap_content and minHeight/Width over hardcoding layout limits. This allows the content to scale to different lengths and sizes. When using constraint layout, make sure to set start AND end constraints, so the view does not end up out of visible screen space.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/0*lfHO8N15O6oehurr.png" /><figcaption>Screenshot showing an example of text getting cut off at larger font sizes</figcaption></figure><p>In this screenshot, TextView height is constrained, so when the text grows beyond the height, it gets unreadable. In the code below, adding the minHeight attribute instead of fixed height allows the field to grow and remain usable.</p><pre>&lt;TextView<br>            android:layout_width=&quot;wrap_content&quot;<br>            android:layout_height=&quot;32dp&quot;<br>            android:text=&quot;Hello&quot;<br>            android:textSize=&quot;48sp&quot; /&gt;</pre><pre>&lt;TextView<br>            android:layout_width=&quot;wrap_content&quot;<br>            android:layout_height=&quot;wrap_content&quot;<br>            android:minHeight=&quot;32dp&quot;<br>            android:text=&quot;Hello&quot;<br>            android:textSize=&quot;48sp&quot; /&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/0*lp5FmDrvTD_T1qPZ.png" /><figcaption>Screenshot showing two text elements, and in the first case, text goes beyond the boundary of the screen.</figcaption></figure><p>In this screenshot, the text has grown beyond the boundary of the screen. This can easily happen if the content is coming from the API and is longer than it was initially expected to be, especially with increased font size. Where no issues would happen in the following code example with short text, it’s important to think about having constraints at both sides of the elements to avoid issues when the text length changes.</p><pre>&lt;TextView<br>        android:id=&quot;@+id/title&quot;<br>        android:layout_width=&quot;wrap_content&quot;<br>        android:layout_height=&quot;wrap_content&quot;<br>        android:layout_marginStart=&quot;40dp&quot;<br>        android:text=&quot;Title&quot; /&gt;</pre><pre>    &lt;TextView<br>        android:layout_width=&quot;wrap_content&quot;<br>        android:layout_height=&quot;0dp&quot;<br>        android:text=&quot;@string/long_text&quot;<br>        app:layout_constraintStart_toStartOf=&quot;@+id/title&quot;<br>        app:layout_constraintTop_toBottomOf=&quot;@+id/title&quot; /&gt;</pre><p>Adding a constraint for the end as well fixes this issue and all text remains visible.</p><pre>&lt;TextView<br>        android:layout_width=&quot;0dp&quot;<br>        android:layout_height=&quot;0dp&quot;<br>        android:text=&quot;@string/long_text&quot;<br>        app:layout_constraintEnd_toEndOf=&quot;@id/title&quot;<br>        app:layout_constraintStart_toStartOf=&quot;@+id/title&quot;<br>        app:layout_constraintTop_toBottomOf=&quot;@+id/title&quot; /&gt;</pre><h3>3. Text overlays other elements</h3><p>In some cases, the views overlay each other. This causes unreadable screens, especially if several text views end up on top of each other. It can be caused by badly defined constraints. For example, an icon starts overlaying the text as the text becomes longer through the font sizing. This problem can also often be seen with translated text when some languages use much longer text than the one for which the app was designed in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/0*GRAEKWKsCeHSCKuU.jpeg" /><figcaption>Screenshot showing icon overlaying text view at larger font size and fixed version</figcaption></figure><p>In the screenshot, TextView is not constrained at the end and grows to overlay the icon. This makes it hard to read the text and to see what the icon is to get more context.</p><pre>&lt;TextView<br>        android:layout_width=&quot;wrap_content&quot;<br>        android:layout_height=&quot;wrap_content&quot;<br>        android:text=&quot;Hello World&quot;<br>        android:textSize=&quot;20sp&quot;<br>        app:layout_constraintStart_toStartOf=&quot;parent&quot; /&gt;</pre><pre>    &lt;ImageView<br>        android:layout_width=&quot;wrap_content&quot;<br>        android:src=&quot;@drawable/ic_android&quot;<br>        app:layout_constraintEnd_toEndOf=&quot;parent&quot;<br>        android:layout_height=&quot;wrap_content&quot;/&gt;</pre><p>To fix this, TextView is constrained against the icon, so the elements cannot end up on top of each other.</p><pre>&lt;TextView<br>        android:layout_width=&quot;0dp&quot;<br>        android:layout_height=&quot;wrap_content&quot;<br>        android:text=&quot;Hello World&quot;<br>        android:textSize=&quot;20sp&quot;<br>        app:layout_constraintStart_toStartOf=&quot;parent&quot;<br>        app:layout_constraintEnd_toStartOf=&quot;@+id/image&quot; /&gt;</pre><h3>4. Unusable ellipsizing</h3><p>Another common issue is when the text scales or when the content is longer than planned for and it becomes ellipsized. Ellipsizing by itself is not an issue, it is a great technique to use in some scenarios. For example, if the user is looking at a preview of an article and can click through to the details to read more. However, the information can be easily lost in snackbars, titles, or error messages, especially if there is something crucial at the end.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/0*_LXY_868IqN5amdu.png" /><figcaption>Screenshot showing an error message with the number at the end cut off at larger font size</figcaption></figure><p>There are various ways to fix this; one method is that the views could be set to allow multiple lines if the text can potentially expand over the limit. It is also helpful to think about whether the content needs to be fully visible to the user on their current screen (text in the article, error message) or whether it could be ellipsized and still make sense without the full text (clickable title in a list which links to detail).</p><h3>How to test</h3><p>There are a few ways to test and catch most of these scenarios.</p><h3>Android Studio</h3><p>When editing a layout in Android Studio, the layout can be previewed in different devices, which helps to catch issues with smaller screen sizes.</p><p>Android Studio also includes the Layout Validation tool which can show a preview with different font sizes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/0*6O9PyHZzIBok13RY.png" /><figcaption>Screenshot from Android Studio showing Layout Validation tool</figcaption></figure><h3>Device testing</h3><p>Manual testing on a device or an emulator helps to catch issues as well. Often, a small set of emulators is enough, as the device settings can be used to test different configurations. My approach is modifying the font size first and then the display size.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/0*-dEd26wksjEzgtR6.jpeg" /><figcaption>Screenshot showing Android font and display size settings</figcaption></figure><h3>To sum up</h3><ul><li>Plan for flexible layouts and consider what happens when text expands beyond the default size.</li><li>Test with different font and display sizes to find issues with scaling.</li><li>We (mostly) don’t build the apps just for ourselves: usability is important.</li></ul><p>I hope this article gave you some tools to make your apps better. Code examples in the article have been shortened to only show the important lines of code. A Github repository containing the full sample code used for examples and generating screenshots is available <a href="https://github.com/sigute/TextViewSizingDemo">here</a>.</p><p><em>Article previously published at </em><a href="https://dev.to/sigute/accessible-text-scaling-for-android-1ham">https://dev.to/sigute/accessible-text-scaling-for-android-1ham</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a62e0b14006" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Accessible Reordering For Touch Devices]]></title>
            <link>https://medium.com/microsoft-mobile-engineering/accessible-reordering-for-touch-devices-e7f7a7ef404?source=rss-de2af152264e------2</link>
            <guid isPermaLink="false">https://medium.com/p/e7f7a7ef404</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[user-experience]]></category>
            <category><![CDATA[microsoft]]></category>
            <dc:creator><![CDATA[Sigute]]></dc:creator>
            <pubDate>Wed, 29 Apr 2020 15:09:54 GMT</pubDate>
            <atom:updated>2020-04-29T15:09:54.132Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Person using Microsoft To Do app with list open in reorder mode" src="https://cdn-images-1.medium.com/max/1024/1*NQ74Lqvr_B086QMDe752Gw.jpeg" /></figure><p>In Microsoft To Do we put a lot of work into making our features available for everyone using our apps. We discovered that the way our task reordering was implemented was not accessible and this is how we approached this problem.</p><h3>Drag and Drop Challenges</h3><p>In Microsoft To Do apps the functionality to reorder the list of tasks was only available via drag and drop, which uses <a href="https://w3c.github.io/wcag21/understanding/pointer-gestures.html">pointer gestures</a>. Pointer gestures work well to allow user interaction with the interface directly, however not every user is able to carry out these gestures. The following user groups could struggle with this approach in different ways:</p><ul><li>Users with motor disabilities might not be able to accurately execute the gesture.</li><li>Users using a keyboard or other input device might not be able to carry out gestures at all.</li><li>Users navigating via Talkback might find it hard to accurately drag an item without seeing where it is going.</li><li>Other users might be simply unfamiliar with drag and drop interaction and not be able to discover it easily when using the app, therefore missing out on this feature.</li></ul><p>We were going to keep the existing drag and drop implementation, as it is already used by many of our users and it is an important part of our app. However, we also needed to remove the barrier which prevented some of our users from reordering the list. As such, we decided to tackle this challenge and find an alternative way to reorder users who were not using pointer gestures. We had to get creative to find a solution.</p><h3>Research</h3><p>As we began researching potential solutions, we found some resources which looked promising.</p><ul><li>Harris Schneiderman <a href="https://www.smashingmagazine.com/2018/01/dragon-drop-accessible-list-reordering/">described</a> a great approach on Smashing Magazine which uses aria live regions and a keyboard to reorder items.</li><li>Jesse Hausler and Cordelia McGee-Tubb <a href="https://medium.com/salesforce-ux/4-major-patterns-for-accessible-drag-and-drop-1d43f64ebf09">shared</a> accessible drag and drop approaches from Salesforce, making use of aria live regions and attributes as well.</li><li>In the <a href="https://accessibility-club.org/">Accessibility Club</a> Summit 2019 here in Berlin, Sergei Kriger <a href="https://www.sergeikriger.com/slides/a11y-club-2019/">shared</a> strategies on how to make draggable components usable to people relying on screenreaders .</li></ul><p>These resources were really helpful when trying to understand the problems experienced with drag and drop, the functionality that would need to be provided and the announcements which are expected by the users who use a screenreader.</p><p>These solutions, however, mainly relied on keyboard navigation. Of course external keyboard can be used with mobile phones, but we would not expect every user who wants to reorder their list to use one. We needed a solution which did not rely on additional accessories.</p><h3>Design Explorations</h3><p>We started with Android in order to allow us to focus on one platform at a time and test our concepts before expanding to other clients. We decided to incorporate action mode, which is common in Android apps to allow users to enable reorder mode. Two potential concepts then emerged for how the interaction would work from there.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*L0hKjgs1wLwmv82uI7MfWw.png" /><figcaption>Screenshot showing “Reorder tasks” option in overflow menu</figcaption></figure><h4>Concept 1</h4><p>When reorder mode is active, we show buttons on each item to allow the user to move the item up or down by one space. As items move, the focus stays with the selected item, so Talkback and keyboard users do not lose their place in the list. This approach only allows the user to move one item at a time, so it might take a long time to reorder everything if the list is very long (this limitation also applies to drag and drop).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*p2Pwqv81v2lgO71b-0_agA.png" /><figcaption>Mockup of grocery list with up and down buttons on each item cell</figcaption></figure><h4>Concept 2</h4><p>For this concept, the user needs to select one or multiple items first before moving them. We show the buttons at the top which allow the user to move all selected items either by one space or all the way to the top or bottom of the list. This approach is more powerful, allowing the user to arrange multiple items at a time. The challenge here is managing the focus between the list and the top bar and making it clear to the user how to select items before moving.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*bTI7vn7NNlOie9NeU_nOLg.png" /><figcaption>Mockup of a grocery list with some items selected and controls to move items at the top action mode</figcaption></figure><h3>Verifying Concepts</h3><p>To verify concepts we worked in parallel; while I was prototyping the concepts in a sample app to figure out technical challenges for both approaches, Lene built design prototypes which we sent to user testing to gather feedback.</p><p>Ioannis has arranged user testing via <a href="https://www.usertesting.com/">usertesting.com</a>. Testing remotely allowed us to get the results back very quickly. 9 participants tried out both concepts at randomised order, which ensured the test was not biased towards one solution .</p><p>We found out that the reorder feature was easily discoverable in both cases, though some participants started by trying drag and drop straight away, showing familiarity with how reorder would normally work in Android apps. There were no concerns over how to exit reorder mode. With concept 1 some testers were lacking the option to move multiple items at a time, while with concept 2 there was some confusion over selecting items first and distinguishing between the buttons for moving one space at a time versus all the way to top/bottom.</p><p>By observing the user interaction with the prototypes, we could clearly recognise a preference for concept 1 by most of the participants.</p><p>When it came to code prototypes, concept 2 needed additional work to make item selection and focus changes clear and easily discoverable, where concept 1 was much more straightforward to implement and to add to current Microsoft To Do codebase.</p><p>To sum up, these were the main properties of each approach:</p><p><strong>Drag and Drop</strong></p><ul><li>discoverable if user is already familiar with Android ecosystem</li><li>not accessible without pointer gestures</li><li>challenging to use with Talkback</li></ul><p><strong>Concept 1</strong></p><ul><li>easily discoverable</li><li>intuitive</li><li>accessible without pointer gestures</li><li>works with Talkback and keyboard</li></ul><p><strong>Concept 2</strong></p><ul><li>easily discoverable</li><li>powerful interface, allowing multiple item reordering</li><li>needs more work to make the interface clear</li><li>accessible without pointer gestures</li><li>unclear Talkback and keyboard navigation</li></ul><p>Based on our technical explorations and the user testing results, we decided to work on releasing concept 1 to provide the currently missing functionality, then would gather user feedback and revisit this feature at a later date to make further improvements.</p><h3>Implementation</h3><p>Microsoft To Do Android app uses RecyclerView for displaying the tasks in the list. We added additional reorder options to the overflow menu and used ActionMode.</p><p>ActionMode.Callback was used for adjusting the interface for reorder mode and then setting it back after the user finished reordering the list items. Our RecyclerView.Adapter includes a new mode for reorder, which refreshes the list elements and shows new buttons on each ViewHolder for moving item up/down.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1336233850d21df6bbc9d1746c9ea752/href">https://medium.com/media/1336233850d21df6bbc9d1746c9ea752/href</a></iframe><p>The other interfaces are also simplified when reorder mode is open, including removing a button for creating new items and modifying the items themselves to show only information relevant for reordering. For some elements views were disabled rather than completely hidden. For example, the user can still see the importance of the item while in reorder mode, but cannot mark the item as important until reorder mode is exited. This improves the user experience by making sure users can clearly focus on the task at hand — reordering. It also makes Talkback and keyboard navigation simpler, by not having as many elements to go through.</p><p>Accessibility announcements were also used to inform Talkback users about the changes. This included announcements for opening and closing reorder mode, as well as announcements when the item is moved up or down.</p><p>As the user navigates through the list and moves the items, it is also important to keep the focus on the right item. It ensures the user keeps their place in the list and does not have to navigate through the entire list again after an item is moved. This was achieved by using techniques covered in a <a href="https://medium.com/android-microsoft/android-accessibility-resolving-common-talkback-issues-3c45076bcdf6">previous blog post</a> about Android accessibility.</p><h3>To sum up</h3><p>This is what the final result in the Microsoft To Do app looks like. The feature has been released — download <a href="https://play.google.com/store/apps/details?id=com.microsoft.todos">Microsoft To Do</a> and try it out yourself!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*G5gZTojROLGEBUjB9GD27Q.gif" /><figcaption>GIF showing reorder mode flow</figcaption></figure><p>We learned a lot about how to handle pointer gestures while working on this. We are sharing our approach with the community as we want to help more teams to support the needs of every user in their apps. Have you worked on any difficult accessibility problems? We would love to read about the solutions you came up with!</p><p><strong>Participants from Microsoft To Do team</strong></p><ul><li>Sigute Kateivaite — research, code explorations, Android implementation / <a href="https://twitter.com/Sigute_K">twitter.com/Sigute_K</a></li><li>Lene Rydningen — research, design concepts and prototypes / <a href="https://www.lenerydningen.com/">www.lenerydningen.com</a></li><li>Ioannis Kiossis — user testing / <a href="https://twitter.com/ioakio">twitter.com/ioakio</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7f7a7ef404" width="1" height="1" alt=""><hr><p><a href="https://medium.com/microsoft-mobile-engineering/accessible-reordering-for-touch-devices-e7f7a7ef404">Accessible Reordering For Touch Devices</a> was originally published in <a href="https://medium.com/microsoft-mobile-engineering">Microsoft Mobile Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android Accessibility — Resolving common Talkback issues]]></title>
            <link>https://medium.com/microsoft-mobile-engineering/android-accessibility-resolving-common-talkback-issues-3c45076bcdf6?source=rss-de2af152264e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c45076bcdf6</guid>
            <category><![CDATA[android-development]]></category>
            <category><![CDATA[microsoft]]></category>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Sigute]]></dc:creator>
            <pubDate>Wed, 18 Mar 2020 15:05:06 GMT</pubDate>
            <atom:updated>2020-03-18T15:05:06.421Z</atom:updated>
            <content:encoded><![CDATA[<h3>Android Accessibility — Resolving common Talkback issues</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-hc-6RaECZk6G2QBDELd7g.jpeg" /><figcaption>A path through the forest by <a href="https://www.pexels.com/photo/landscape-photo-of-pathway-between-green-leaf-trees-615348/">Skitterphoto</a></figcaption></figure><p>Many Android applications suffer from similar Talkback issues and at Microsoft To Do we run into these often as well. We use multiple strategies to make our app more accessible. This article covers a few scenarios where Talkback experience is improved.</p><p>A companion Github repository containing the sample code is available <a href="https://github.com/sigute/AccessibilityTipsDemo">here</a>. You can check it out and try running the demo app on your device to experience the issues and try the solutions yourself.</p><h3>Combining views into groups</h3><p>Not everything visible on the screen is meaningful; some views are used only for decoration, some images illustrate the text without adding additional information, and sometimes multiple views convey the meaning together but do not make sense separately. In these cases, the views can be combined to allow Talkback user to quickly navigate entire view, rather than having to skip through multiple different elements.</p><h4>Example</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nUxNfkMKH-mGwv7wEWFGkw.png" /><figcaption>Screenshot showing Talkback navigation over ungrouped elements</figcaption></figure><p>Talkback reads the user element on the page as “User placeholder avatar”, “Name”, and then “Surname”. Each element can be navigated individually. The user icon is a placeholder which does not provide additional information. It takes three swipes to navigate through the element.</p><h4>Solution</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*hMrl7KbahPychtay1i-OWw.png" /><figcaption>Screenshot showing Talkback navigation over group</figcaption></figure><p>Content description is set on the entire group so Talkback reads only one label, containing all user information as “Name Surname”. Now navigation is done in only one swipe.</p><h4>XML layout snippet</h4><p>Content description is set on <em>LinearLayout</em>, child views are marked as not important for accessibility individually.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/291a5aa3ed9b9b773563d19e0a1c36a9/href">https://medium.com/media/291a5aa3ed9b9b773563d19e0a1c36a9/href</a></iframe><h3>Action descriptions</h3><p>As Talkback navigates the elements with click actions, the announcement generated will include some information, for example “Login, Button, Double tap to activate”. However, relying on default announcements is not always enough.</p><h4>Example</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_j9cjnQP_7nxmrCDOZDXBA.png" /><figcaption>Screenshot showing Talkback announcements for the Button without custom actions</figcaption></figure><p>A button with two actions generates an accessibility announcement of “Edit note, Double tap to activate, Double tap and hold to long press”.</p><h4>Solution</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5YTCgfnQlHsMl32_fAgEZw.png" /><figcaption>Screenshot showing Talkback announcements for the Button with custom actions</figcaption></figure><p>Actions are modified to announce “Double tap to edit note, Double tap and hold to copy note”.</p><h4>Code snippet</h4><p>Custom actions are added in accessibility delegate, ensuring that it’s clear what happens when each action is carried out.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ee53a5936a1f99e2180666d2226c101f/href">https://medium.com/media/ee53a5936a1f99e2180666d2226c101f/href</a></iframe><h3>Roles</h3><p>Talkback reads the element roles, such as Button, Switch, Checkbox, etc. This gets complicated when non-standard elements are used. For example, adding a click listener will add an action to Talkback announcement, but the role will generally not change, potentially causing confusion.</p><h4>Example</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X4-t4BMcybL-eTDr4cymUg.png" /><figcaption>Screenshot showing examples of different types of buttons and Talkback announcements</figcaption></figure><p>The button is announced as “Login, Button”. Adding on a click listener to TextView does not include the “Button” announcement. In the last example, TextView is announced as “Button”.</p><h4>Code snippet</h4><p>Role is added by including it in the accessibility delegate. This is not an ideal solution; best practice is to use elements as intended, so using Button when Button behaviour is needed, which avoids the need to modify roles manually, as it is easy to miss some behaviour which comes by default. However, in some cases, this will help.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b4369033ac091f9da559675702cdfd90/href">https://medium.com/media/b4369033ac091f9da559675702cdfd90/href</a></iframe><h3>Updating information after state changes</h3><p>Lint warning often reminds us about adding initial content descriptions, but for the elements with states, this might not be enough. It is important to remember to update accessibility information as well.</p><h4>Example</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wy4iGfMV-1J7ieYudfmPKQ.png" /><figcaption>Screenshots showing Talkback announcements for Buttons where UI changes but accessibility information is not updated</figcaption></figure><p>The favorite button is not updated after the user taps on it, so the Talkback announcement still reads “Not favorite item, Button, Double tap to activate” after the user already added the item to favorites and the UI is updated to reflect this.</p><h4>Solution</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*21zUvodPIqWvHPaMamN61g.png" /><figcaption>Screenshots showing Talkback announcements with changed UI and accessibility information</figcaption></figure><p>Favorite button content and action descriptions are updated so Talkback reads one of two states: “Not favorite item, Button, Double tap to add to favorites” and “Favorite item, Button, Double-tap to remove from favorites”.</p><h4>Code snippet</h4><p>When a tap event is received and the element state changes, the content and action descriptions are updated to reflect the current state of the item. This is especially important for elements which represent On/Off state, like the favorite button. Alternatively, an element which already supports On/Off states could be used in this scenario, like Switch or Checkbox. On the other hand, if more than two states are available, then custom elements make sense.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2aa45676fe444b80feff6e9470b6ea20/href">https://medium.com/media/2aa45676fe444b80feff6e9470b6ea20/href</a></iframe><h3>RecyclerView scrolling</h3><p>If RecyclerView does not automatically scroll with Talkback navigation, it will make it very hard for Talkback users to know that there are more elements available. There is one common issue which usually causes this.</p><h4>Example</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*IauR5wWRBME9ZqyCltJFvw.gif" /><figcaption>GIF showing side by side comparison of Talkback navigation of scrolling and non-scrolling RecyclerView</figcaption></figure><p>The first RecyclerView allows user to see the first 5 elements and then navigation skips the rest. The second RecyclerView moves to the 6th element in the list and scrolls down to make additional elements available. The focus only moves away from RecyclerView when all elements are visited.</p><h4>Layout snippet</h4><p>If the following line is in the RecyclerView layout, removing it will fix the issue. It will also add additional in/out of list announcements to help the users navigate.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cc959bd8a4c18b813a1420a469e2685e/href">https://medium.com/media/cc959bd8a4c18b813a1420a469e2685e/href</a></iframe><h3>RecyclerView focus</h3><p>As is the nature of RecyclerView, it can recycle the view holders if there are changes to the data. However, this can create focus issues if some view is no longer displayed or the view holder is reused in a different position. Understanding what is happening will help with keeping the focus unchanged.</p><h4>Example</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*otruyFJuFWQ69rY_VStjRQ.gif" /><figcaption>GIF showing side by side Talkback navigation of RecyclerView with focus issues and a fix</figcaption></figure><p>RecyclerViews allow the user to mark elements as deleted. In the first RecyclerView, once the delete icon is tapped and the element text is replaced with “Deleted &lt;name&gt;”, the focus returns to the top of the activity, so the user needs to navigate through the entire screen again to return to the original focus position. The second RecyclerView keeps the focus on the same element, shifting it from the icon to the name.</p><h4>Code snippet</h4><p>After the element is marked as deleted there is a short delay to allow RecyclerView time to reuse ViewHolders, then the desired position is found and focus is returned to that position. If the underlying data set is not changed and there is no refresh of the data in RecyclerView adapter, this could potentially be solved within ViewHolder itself. As always, the best solution is the one which addresses the specific need.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2ec623f2356a72e5b5903f4cb10214cf/href">https://medium.com/media/2ec623f2356a72e5b5903f4cb10214cf/href</a></iframe><h3>Conclusions</h3><p>Accessibility is important for our team at Microsoft To Do. We spend a lot of time making sure every user can stay organised and accomplish more, independent of how they use their device. Most of our Android app releases include several accessibility improvements. We also work with our design team to consider accessibility requirements from the start.</p><p>Accessibility issues we encounter range from simple to tricky — it takes time and dedication to find and resolve them all. I hope this article helps you to solve some. Code snippets in the article have been simplified for clarity, so check the sample code for full implementations.</p><p>Is there a different way you would approach some of these? Let’s discuss it!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c45076bcdf6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/microsoft-mobile-engineering/android-accessibility-resolving-common-talkback-issues-3c45076bcdf6">Android Accessibility — Resolving common Talkback issues</a> was originally published in <a href="https://medium.com/microsoft-mobile-engineering">Microsoft Mobile Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Improving Pull Request Process with Complexity Labels]]></title>
            <link>https://sigute.medium.com/improving-pull-request-process-with-complexity-labels-e47a59c54f21?source=rss-de2af152264e------2</link>
            <guid isPermaLink="false">https://medium.com/p/e47a59c54f21</guid>
            <category><![CDATA[pull-request]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Sigute]]></dc:creator>
            <pubDate>Thu, 12 Mar 2020 18:10:36 GMT</pubDate>
            <atom:updated>2020-03-12T18:10:36.910Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PalPEFVJ1AvzMAD7ToxhXQ.jpeg" /><figcaption>Sticky notes and pens by <a href="https://www.pexels.com/photo/white-click-pens-1017502/">Maria Tyutina</a></figcaption></figure><p>Does your team struggle with pull requests? Is there never enough time in the day to review others code? Do you feel like you need to keep asking your teammates for code reviews? Is the list growing everyday with no end in sight? Pull requests <strong>are</strong> hard. Our Android team at Microsoft To Do made some changes recently to improve the process. I have suggested adding labels to pull requests and this article shows my solution.</p><h3>What is complexity</h3><p>To start with, I thought about how we define complexity. Take a moment to consider these: What makes a pull request easier or harder to review? Is there a type of pull request which always get merged straight away and another one that sits there for a long time? What’s the difference between them?</p><p>In general, the smaller the pull request, the easier and faster it should be to review. This is a good general rule, however one line change is not always straight forward in terms of impact. Fixing a typo is easy. Updating an external dependency also changes only a few characters, but might lead to the entire app breaking.</p><p>However, considering only the number of lines of code changing can be misleading if it is the only way to think about complexity. On the other side of this, large pull requests are not necessarily complex. Renaming something might affect hundreds of files but the risk is low, especially with modern tools where forgetting some files is less likely. Adding in new translations could also generate very large changeset, but is unlikely to generate new bugs.</p><h3>Complexity Matrix</h3><p>After considering size and difficulty, I have arrived at complexity as the measure of pull request.</p><blockquote><strong>Size x Difficulty = Complexity</strong></blockquote><p>I have created this matrix as a way to think about complexity and roughly estimate where pull request might fall into.</p><figure><img alt="A table showing size and difficulty with 4 corners highlighted, summarised further below" src="https://cdn-images-1.medium.com/max/880/0*ttRVXwOCJ6PjhpFk.png" /></figure><h3>Easy — small size and low difficulty</h3><p>These are your small and simple pull requests. This is the quickest pull request type to review and the easiest to test. Changes are unlikely to cause further issues. These pull requests tend to get merged very quickly.</p><h3>Medium Low — large size and low difficulty</h3><p>These are pull requests which are large, but the changes themselves are trivial. They can take longer to review because of the size, but are also less likely to introduce further bugs.</p><p>Where possible, it could be beneficial to split these pull requests into multiple smaller ones.</p><h3>Medium High — small size and hard difficulty</h3><p>These are pull requests which do not change many lines of code, but could have a big impact. This includes changing business logic, UI elements, updating dependencies, etc. These changes can potentially have unforeseen effects, so need to be reviewed and tested carefully.</p><p>This is the category where using strategies like A/B testing, feature flags and and staged releases could be very beneficial, so changes can be reverted easily in case of any issues, whether with code or with user impact (for example if new UI does not perform as well as expected).</p><h3>Large — large size and hard difficulty</h3><p>The final category is the pull requests which are large and complex. This could be things like adding a new screen to the app, changing one dependency to another, refactoring, etc. The bigger a pull request grows in this area, the harder it is to keep track of changes and carry out a good code review.</p><p>The best strategy here is to be careful about creating pull requests in this category. If the code changes are growing, could they be split across multiple code reviews? For example, for a new app feature, database changes could be reviewed separately from the UI layer. Using feature flags to hide code which is not ready for production yet helps with this, so the feature branch does not grow too much out of sync with the main branch.</p><h3>How to put this into practise</h3><p>We have started labelling our pull requests as part of the title and use t-shirt sizes as the complexity:</p><blockquote><em>S -&gt; M -&gt; L -&gt; XL -&gt; … -&gt; XXXXXXL?</em></blockquote><p>Some examples of pull request titles would look like this:</p><blockquote><em>[S] Fixed accessibility bug in X screen</em></blockquote><blockquote><em>[M] Updated library Y dependency, please test</em></blockquote><p>Alternative labels could include emojis!</p><blockquote><em>🐇 -&gt; 🦘 -&gt; 🦙 -&gt; 🦖</em></blockquote><blockquote><em>😀 -&gt; 🙂 -&gt; 😐 -&gt; 😭</em></blockquote><p>Be aware that emojis appear differently on other devices, dependent on platform, OS, and many other factors, so make sure the selected ones look good on all your teammates computers!</p><p>If you want to use animal emojis, I have categorised some of them by size!</p><h3>Sigute 🦇 on Twitter</h3><p>XS: 🐁🐀🦇🐠🐡🐌🦋🦎🐛🐜🐝🐞🦗🦐 S: 🐩🐇🐓🕊🦝🐕🐈🐿🦔🦆🦜🐢🦀🦞 M: 🐒🐐🦘🦃🦡🦉🐟🐙🦑🦚 L: 🐏🐑🦢🦙🐄🦍🐃🦓🦈🐖🐅🐆🐎🦌🐂🐪🦒🦅🐊🐬 XL: 🐘🦏🦛🐳🐋🦕🦖🐉</p><p>As well as using the label as part of the title, you could make use of labels in your code review tools.</p><p>If you are using Github, you can create custom labels and then add them to pull requests. Emojis and colours are supported and you will be able to filter by specific label.</p><figure><img alt="Screenshot of Github pull requests with custom complexity labels" src="https://cdn-images-1.medium.com/max/738/0*5KMM_Qt8oAYAOS2_.png" /></figure><h3>Impact of changes</h3><p>It has been a few weeks since our team started adding a complexity label when making new pull requests. In general, the feedback has been great! This approach encourages us to think about how complex the changes are when we add new code to Android Microsoft To Do app.</p><p>The benefits of this approach so far include:</p><ul><li>Telling at glance how much time it might take to review the changes. This helps to plan which pull requests might need a longer time to review and what can be quickly reviewed in the spare 10 minutes between other tasks.</li><li>Thinking about complexity when creating pull requests and strategies to mitigate risk.</li><li>The pull request list becomes more manageable.</li></ul><p>We did not experience any big issues, but a few things we discovered:</p><ul><li>It is hard to get used to any new approach, so remembering to add a label is not automatic yet.</li><li>Our release notes made use of pull request titles for the draft version, so we had to add an additional script to strip the labels out as part of our continuous integration process.</li></ul><p>As a closing thought, I would encourage you to be forgiving about the labels. They are rough indicators intended to help with the process. If you are getting lost in conversations over whether a pull request is XL or XXL, you are missing the point! 😀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e47a59c54f21" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android Accessibility — Where to start?]]></title>
            <link>https://medium.com/microsoft-mobile-engineering/android-accessibility-where-to-start-b7875045d9?source=rss-de2af152264e------2</link>
            <guid isPermaLink="false">https://medium.com/p/b7875045d9</guid>
            <category><![CDATA[a11y]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Sigute]]></dc:creator>
            <pubDate>Tue, 11 Feb 2020 20:10:45 GMT</pubDate>
            <atom:updated>2020-03-09T11:24:22.431Z</atom:updated>
            <content:encoded><![CDATA[<h3>Android Accessibility — Where to start?</h3><figure><img alt="A question mark drawn on blackboard with white chalk" src="https://cdn-images-1.medium.com/max/1024/1*hxujizDOEBn0EKe5xbhCsA.jpeg" /><figcaption>Question mark by <a href="https://www.pexels.com/photo/ask-blackboard-chalk-board-chalkboard-356079/">pixabay.com</a></figcaption></figure><p>Making sure as many people as possible can use an app you are developing is so important for many of us. If you are just starting to think about accessibility in your Android app, it can be hard to understand what the requirements are and how to get started. This article will allow you to start exploring common accessibility issues in Android apps; making these small improvements will help many users of your app.</p><h3>Tools</h3><p>The main tools used for Android accessibility testing are offered by Google and many come pre-installed on every device. The main ones you need to start with are:</p><h4>Talkback</h4><p>Most devices have either <a href="https://support.google.com/accessibility/android/answer/6283677?hl=en">Talkback</a> or a similar screen reader already pre-installed. Once enabled, a tutorial is provided so you can learn how to navigate. With Talkback, captions can be enabled in the settings and are helpful to verify the announcements, and if you need to take a screenshot to share with other members of the team this is a useful feature.</p><p>Enable Talkback and captions:</p><blockquote>Settings -&gt; Accessibility -&gt; Talkback -&gt; Settings -&gt; Developer Settings -&gt; Display speech output</blockquote><h4>Accessibility Scanner</h4><p><a href="https://play.google.com/store/apps/details?id=com.google.android.apps.accessibility.auditor">Accessibility Scanner</a> is a tool made by Google specifically for finding common accessibility issues and is very easy to use. It can be downloaded and installed from the Play store. Once installed, any screen in any app can be scanned for issues.</p><h4>Contrast checker</h4><p>After finding issues, sometimes tweaking colours is enough to resolve them. There are many contrast checkers available, I like the <a href="https://webaim.org/resources/contrastchecker/">WebAIM</a> one as it checks both text and other elements.</p><h3>5 places to start</h3><p>My advice is to start with these areas to address the most common issues found in many apps. When we think about accessibility in apps, we often think about vision impairments, including vision loss. Another area to think about is mobility impairments which can make it difficult to use controls and navigation.</p><h4>Labels and content descriptions</h4><p>Launch Talkback and start checking what announcements are made as you focus on various views in the app. Some questions to keep in mind while testing:</p><ul><li>Do buttons have labels?</li><li>Do images have content descriptions?</li><li>Do labels match what is actually shown on the screen?</li><li>When the element state changes, is the content description updated? (for example, ticked and unticked radio button)</li><li>Are there some elements which are only decorative and should not be announced?</li></ul><p>Fixing issues in this category is usually straightforward. Content description can be added and updated. Decorative elements can be labelled as not important for accessibility and will be skipped. Android Lint provides some warnings for missing accessibility features, and addressing these will help.</p><p>The aforementioned Accessibility Scanner will catch a lot of these issues too.</p><h4>Navigation</h4><p>Talkback is the tool to use for this category. Keyboard navigation follows similar paths, so it could be used for testing as well.</p><ul><li>As you navigate through the app, does focus jump around or is the order followed logical?</li><li>Do you lose focus and need to start at the top of the page again?</li><li>Can all areas be accessed without tapping on the screen directly?</li><li>Does Talkback focus on each element separately or can some elements be grouped? (for example, user name could be navigated as “Name”, “Surname” or as one “Name Surname” element)</li></ul><p>Fixing navigation can be challenging, so deciding on the strategy early rather than trying to retrofit the solution later is often the best approach. Some things to look into for this category include the accessibility traversal order, setting content descriptions on groups rather than individual items and requesting focus manually on specific elements in some scenarios.</p><h4>Font sizes</h4><p>Changing font to a larger size in device settings will help to check for issues in this area. Display size can be changed as well and should be tested. Things to look for include:</p><ul><li>Does all the text in the app respond to device setting font size?</li><li>Do any elements overlap each other?</li><li>Is any text cut off and cannot be read anymore?</li></ul><p>To fix issues in this area, look for any usages of <em>dp</em> instead of <em>sp</em> for text sizing. Make sure elements scale to match the text sizes and prefer scrollable screens which can accommodate additional height if needed. For the individual views, it is best to avoid fixed height and width. Setting the view height and width to <em>wrap_content</em> and using <em>minWidth</em> and <em>minHeight</em> attributes will help with the scaling.</p><h4>Contrast</h4><p>Contrast can be checked using Accessibility Scanner and other contrast checker tools. It might be hard to determine contrast ratio just by looking. Some questions you might ask are:</p><ul><li>Are any colours very similar to each other?</li><li>Can tappable elements be easily distinguished?</li><li>Is there a rule for what colours of background and text could be used in the app, to make the contrast ratio more predictable?</li></ul><p>General requirement is minimum 4.5:1 contrast ratio of text to background, and 3:1 for controls. Outlines can help to distinguish tappable elements in some cases.</p><h4>Tap target sizes</h4><p>If you ever tried tapping a button multiple times without success, you have ran into this issue. Accessibility Scanner will highlight the areas which are too small to tap accurately. Some things to keep in mind include:</p><ul><li>Is there enough padding to tappable elements?</li><li>Are there a lot of small elements right next to each other, so it’s easy to mis-tap?</li><li>Can the entire element be tapped or is the tap area limited to a small portion of it?</li><li>Can the tap area be expanded?</li></ul><p>Android recommendation is a minimum <em>48x48dp</em> for tappable areas. Some margins between elements, where possible, can also make for a nicer experience.</p><h3>Watch out for…</h3><h4>Custom views</h4><p>If you define your own custom views, be careful. Default Android framework elements come with a lot of built-in accessibility support. Where possible, extending the framework class, like <em>Button</em>, might help to reduce some work vs extending a more generic class, such as <em>FrameLayout</em>, and having to build various states and announcements from scratch.</p><h3>Continue with…</h3><p>Checking for these common issues will help to improve accessibility in your app. However, there are more things to consider to provide a great experience for users with accessibility needs. <a href="https://www.w3.org/WAI/standards-guidelines/wcag/">WCAG guidelines</a> are a great place to go for understanding additional requirements and exploring common solutions.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b7875045d9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/microsoft-mobile-engineering/android-accessibility-where-to-start-b7875045d9">Android Accessibility — Where to start?</a> was originally published in <a href="https://medium.com/microsoft-mobile-engineering">Microsoft Mobile Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Making Android Studio work for me]]></title>
            <link>https://sigute.medium.com/making-android-studio-work-for-me-4aac9680e665?source=rss-de2af152264e------2</link>
            <guid isPermaLink="false">https://medium.com/p/4aac9680e665</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[android-development]]></category>
            <category><![CDATA[android-studio]]></category>
            <dc:creator><![CDATA[Sigute]]></dc:creator>
            <pubDate>Fri, 25 Oct 2019 18:59:19 GMT</pubDate>
            <atom:updated>2019-10-25T18:59:19.955Z</atom:updated>
            <content:encoded><![CDATA[<h4>My tips for customising Android Studio</h4><figure><img alt="Coloring materials, including paintbrushes, pencils and paint" src="https://cdn-images-1.medium.com/max/1024/1*g4ObgbF5mRgnYojEWCxKCA.jpeg" /><figcaption>Colouring materials by <a href="https://www.pexels.com/@sascha-duser-51514">Sascha Düser</a></figcaption></figure><p>When I install Android Studio, I like to make some adjustments which help me be more productive.</p><h3>Theme and fonts</h3><p>I prefer the dark theme for my IDE, I use <a href="https://plugins.jetbrains.com/plugin/7998-chromaterial">ChroMATERIAL</a> Darcula. A dark theme might be helping with eye strain, though the research is <a href="https://onezero.medium.com/dark-mode-isnt-the-answer-to-our-screen-problems-1b9db4ef06fb">inconclusive</a>. I also find the default font too small and help my eyes by adjusting to at least 14pt, depending on the font. My current choice is Hack Nerd Font at 15pt.</p><blockquote>Preferences -&gt; Editor -&gt; Font -&gt; Size</blockquote><p>Cannot see enough lines of code with a bigger font? Make your methods shorter, reducing code complexity.</p><h3>Logcat Colours</h3><p>By default, logcat shows everything in the same colour, making it hard to see a difference between a crash and a simple info log. I change the colours to help me see what is going on a bit easier, as well as making use of filtering features.</p><blockquote>Preferences -&gt; Editor -&gt; Color Scheme-&gt; Android Logcat -&gt; Untick “Use inherited values” and then choose your own colours.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G4LBjGKeW2z1jRLb-TnF4A.png" /><figcaption>The picture shows Android Logcat colour scheme options</figcaption></figure><h3>Code formatting</h3><p>Unused imports, random spaces, inconsistencies between files... They can all be gone with code formatting. Even better, I <a href="https://android.jlelse.eu/android-studio-formatted-save-4db77c4c2396">record a macro</a> to remove unused imports, reformat and save with one easy shortcut. I use ⌘ + S</p><p>Default formatting settings can be used or adjustments made to suit your needs. These can (and should) be shared with the entire team, and there will be no more disagreements about tabs or spaces in pull requests! (everyone knows which one is better 😉)</p><h3>Favourite plugins</h3><p>I also use some plugins. I am not a heavy plugin user, but these are the ones I find pretty helpful.</p><p><a href="https://plugins.jetbrains.com/plugin/10080-rainbow-brackets/">Rainbow brackets </a>— makes matching brackets same colour, easier to quickly see what is going on. You can use the defaults, which are nice, or define a custom style.</p><blockquote>Preferences -&gt; Editor -&gt; Color Scheme-&gt; Rainbow Brackers</blockquote><p><a href="https://plugins.jetbrains.com/plugin/7275-codeglance/">Code Glance</a> — gives some additional context of where I am in the file, how long it is, etc. There are custom settings, but I stick with defaults.</p><p><a href="https://plugins.jetbrains.com/plugin/8575-nyan-progress-bar/">Nyan Progress Bar</a> — just a bit of fun! I spend enough time looking at the progress bar, at least now it is cute…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/161/1*nP7nFX5QR-eUAvV2LPW3SA.png" /><figcaption>Nyan car progress bar</figcaption></figure><p><a href="https://plugins.jetbrains.com/plugin/11286-nyan-tray/">Nyan Tray</a> — adds another Nyan cat, and everyone would want more of these! But it also tells me how long gradle builds have been running in the last day/week/etc. If that number grows, it can indicate that it is time to look into strategies to reduce build times, or maybe upgrade the development machine...</p><p>As well as installing extra plugins, default preinstalled plugins can be disabled. For example, I work with git, so Mercurial and Subversion plugins are not useful to me. I did not notice a difference in performance after disabling them, but it reduced the number of options in the menus, which is still a win, as it helps me to focus on relevant content.</p><h3>Terminal</h3><p>Not strictly Android Studio, but since I use both together every day, it deserves a mention. I use <a href="https://www.iterm2.com/">iTerm2</a> with <a href="https://github.com/robbyrussell/oh-my-zsh">Oh My Zsh</a> to make my terminal look and work better. I have used <a href="https://medium.com/swlh/power-up-your-terminal-using-oh-my-zsh-iterm2-c5a03f73a9fb">these</a> <a href="https://hackernoon.com/how-to-trick-out-terminal-287c0e93fce0">articles</a> to configure mine.</p><h3>Do you have a favourite setting?</h3><p>How do you customise your Android Studio to work for you? Do you prefer all default settings? Let’s talk about it 😄</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4aac9680e665" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tips from attending my first Grace Hopper Celebration]]></title>
            <link>https://sigute.medium.com/tips-from-attending-my-first-grace-hopper-celebration-7a1752627750?source=rss-de2af152264e------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a1752627750</guid>
            <category><![CDATA[grace-hopper]]></category>
            <category><![CDATA[grace-hopper-conference]]></category>
            <category><![CDATA[women-in-tech]]></category>
            <dc:creator><![CDATA[Sigute]]></dc:creator>
            <pubDate>Fri, 18 Oct 2019 20:54:50 GMT</pubDate>
            <atom:updated>2019-10-18T20:54:50.903Z</atom:updated>
            <content:encoded><![CDATA[<h4>Attending Grace Hopper for the first time? I have some advice</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pvGY02gDQXHAyo77f5OnhQ.jpeg" /></figure><p>I have attended my first Grace Hopper Celebration (GHC) this year. I was really excited to go. It is the biggest conference for women in tech fields, named after <a href="https://nam06.safelinks.protection.outlook.com/?url=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FGrace_Hopper&amp;data=02%7C01%7CSigute.Kateivaite%40microsoft.com%7Cb1daf83b0a9d4c53557908d7513d2f93%7C72f988bf86f141af91ab2d7cd011db47%7C1%7C0%7C637067195740642470&amp;sdata=OYKcGPNt%2FfQ8plbwwg%2FZ6S2%2FuStafv6wGoElvRhCXZs%3D&amp;reserved=0">Grace Hopper</a>: computer scientist, admiral, inventor of the first compiler and a lot of other contributions to the fields of computing. GHC has been running since 1994, starting out with 500 attendees. In 2019, this number grew to 26000.</p><p>I was very happy to have a chance to go, but conferences are out of my usual comfort zone and GHC is the busiest conference I ever attended. I try to plan out every conference I go to, but for GHC my planning has been more in depth. There were many things to consider with multiple tracks, busy halls, meeting people, taking notes… I am going to share things I recommend considering.</p><h3>Getting tickets</h3><p><em>This</em> is the hard part! The registration date and time is made available in advance. Be ready at that time, set an alarm. Make sure you have your credit card on hand. Check the social media pages too. After the website became unresponsive this year, direct links to registration were posted on Twitter.</p><h3>Preparation</h3><p>Take some time to consider your goals for attending GHC; what do <em>you</em> want to get out of it? Is it learning about particular topic? Expanding a certain skill set? Attending a workshop? Making new connections? Looking for a new job or internship? Keep your goals in mind as you plan as this will help with managing scheduling conflicts.</p><p>GHC offers session sign-up in advance of the conference. Be ready to register for sessions if there is something you particularly want to attend as this will guarantee your spot. The guidance is to arrive at least 10 mins before the talk starts. I also attended multiple sessions I did not register for — anyone can queue up and event staff will let you know what are your chances of getting in. I was able to get in to every single one I tried, but this may vary for very busy sessions.</p><p>Do not to fill every single gap in your schedule with sessions. I made sure to allow some unstructured time for visiting the careers hall, talking to people, attending some poster sessions and tech showcases. Sessions might also be far away from each other, so you will need time to get from one to another (or wear running shoes, I suppose?). It might be hard to do two sessions right after each other. Some of the popular session have repeat slots, check for these.</p><p>Look at the schedule again closer to the conference. I have reassessed my schedule before each day, so I knew where I needed to be and could add additional notes or drop some sessions if the content seemed too similar to another session I had already attended.</p><h3>Networking</h3><p>You will meet a lot of amazing people and there are many ways to connect and keep in touch after the conference. I have been connecting with people on LinkedIn and Twitter, and the official app also allows you to find other attendees.</p><p>Following Twitter hashtags helped me to find some people to follow, as well as seeing what was going on around the conference and getting some additional tips from talks I did not get a chance to attend.</p><h3>Things to take with you</h3><p>Something for note-taking. This can be laptop, phone, notebook, etc. You can share this with your team or entire internet later (use the hashtags).</p><p>Your phone. GHC was full of amazing photo opportunities and many women helping each other with taking pictures. It also lets you connect with other attendees right away. I did not take my laptop, as it gets heavy to carry it for an entire day, but my phone worked as a schedule, a note-taking app, a networking tool, etc..</p><p>External battery! There were several of charging spots around, which is pretty great, but it does attach you to specific spot. Bringing a portable version helps.</p><p>Hoodie or a jacket. Conference halls were the same as in every conference — on the chilly side.</p><h3>Practice self-care</h3><p>Drink water. There were water fountains throughout the conference halls, it’s important!</p><p>Bring some snacks. Companies were giving out a lot of candy and there were some snacks provided, which is nice. However, I find that bringing something non-sugary helps me to concentrate in the sessions better.</p><p>Take breaks. A full day of talks and meeting new people is exhausting, even going outside for 10 mins helps.</p><p>Get enough sleep. Being well rested makes it much easier to learn new things!</p><p>Wear comfortable shoes. You will walk a lot. Some talks are in completely different buildings, so you will get a lot of steps in.</p><h3>Other advice</h3><p>If you are there a day or two early and can pick up your badge before the conference starts, make sure to do it. I picked mine up in about 2 minutes with no queue at all the day before. On the first day, the queues were at least an hour long.</p><p>After the registration, it’s the keynotes queues that are the longest. In search of the end of the queue on the first morning, I accidentally found the Keynote Overflow Room. The same keynote projected on a big screen away from the biggest crowds. It might lack some of the atmosphere of being in the main keynote presentation, but to me it was worth it :)</p><p>There is pressure to try to do everything, and I had some fear of missing out. In a conference the size of GHC it is normal to miss some things — it would not be possible to attend every talk and go to every party. That’s just fine! I still had a great time even though I am sure I missed some interesting things too. I’ll just have to go again in the next couple of years!</p><h3>Useful resources</h3><p>I read these guides before going to GHC and found them very useful for my preparation:</p><ul><li><a href="https://blog.netapp.com/a-first-timers-guide-to-attending-grace-hopper-celebration/">A First-Timer&#39;s Guide to Attending Grace Hopper Celebration | NetApp Blog</a></li><li><a href="https://code.likeagirl.io/a-guide-to-navigating-grace-hopper-8a1e7693e37e">A Guide to Navigating Grace Hopper</a></li><li><a href="https://blog.powertofly.com/grace-hopper-conference-2018-2603846357.html">The Ultimate Grace Hopper 2019 Guide</a></li></ul><p>I hope you found this useful. I really enjoyed attending the conference, learned a lot and found inspiration. It was great being in the same place as 26000 other tech women, that’s the experience I will never forget!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a1752627750" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I love working with Kotlin]]></title>
            <link>https://sigute.medium.com/why-i-love-working-with-kotlin-a0001a302dc9?source=rss-de2af152264e------2</link>
            <guid isPermaLink="false">https://medium.com/p/a0001a302dc9</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[androiddev]]></category>
            <dc:creator><![CDATA[Sigute]]></dc:creator>
            <pubDate>Mon, 16 Jul 2018 11:09:00 GMT</pubDate>
            <atom:updated>2018-07-16T11:09:00.105Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vf-jfvDPJKYjcvAUXhjYBg.jpeg" /><figcaption>Hand-drawn heart by <a href="https://pixabay.com/en/notebook-address-book-point-sketch-2247351/">pixabay.com</a></figcaption></figure><p>I have been using Kotlin for about a year now, and also started using <a href="https://kotlinlang.org/docs/tutorials/android-plugin.html">Kotlin Android Extensions</a> recently. These are a few of my favourite Kotlin things!</p><h3>Data classes + Parcelize</h3><p>Most Android apps I have worked on needed to fetch data from the network, which means writing a lot of models. This is not the exciting development work anyone really wants to do. Kotlin makes this task a lot less tedious.</p><p><a href="https://kotlinlang.org/docs/reference/data-classes.html">Data classes</a> allow implementing data models in just a few lines. <a href="https://kotlinlang.org/docs/tutorials/android-plugin.html#parcelable">Parcelize</a> from Kotlin Android Extensions adds Parcelable in just one annotation!</p><p>With Java, a simple object model with Parcelable implementation would look something like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/709ec19b1d77cb05fdc0c8e44dddbe03/href">https://medium.com/media/709ec19b1d77cb05fdc0c8e44dddbe03/href</a></iframe><p>Kotlin and Parcelize make all of this possible in only 2 lines.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4bd5415c98a0395593d2d50e4892059c/href">https://medium.com/media/4bd5415c98a0395593d2d50e4892059c/href</a></iframe><p>I have also made use of the <a href="https://github.com/wuseal/JsonToKotlinClass">JsonToKotlinClass </a>Android Studio plug-in recently, which made the process even easier.</p><h3>Null handling</h3><p>A very common app crash — something was null and it was not expected to be. Nullable annotations in Java do help with this. Kotlin does even better by making everything non-null by default. Assigning null leads to the compilation error, forcing the situation to be handled straight away and preventing runtime crashes.</p><p>Where null is possible, safe calls make the null checking much less verbose.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6a1c6c8b0273813dd3bb6edb00517cdf/href">https://medium.com/media/6a1c6c8b0273813dd3bb6edb00517cdf/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8bb619c9381fbbab24e247bc68a6f7fe/href">https://medium.com/media/8bb619c9381fbbab24e247bc68a6f7fe/href</a></iframe><h3>findViewById is gone!</h3><p>Another great Kotlin Android Extension, enabling the use of identifiers defined in XML directly, rather than using <em>findViewById</em>, or adding extra code using some data binding solution. Less code makes it easier to focus on important elements.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b29bbd8aeabac5df26683f4cce4c4c4d/href">https://medium.com/media/b29bbd8aeabac5df26683f4cce4c4c4d/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5a462ee5cac5c34fd6c7b73f046ba878/href">https://medium.com/media/5a462ee5cac5c34fd6c7b73f046ba878/href</a></iframe><h3>Easy migration from Java</h3><p>Java and Kotlin integrate into the same project easily. This allows the migration to be handled in stages, by package or feature, without the pressure to convert the entire codebase in one go.</p><h3>Overall</h3><p>Kotlin makes Android development more pleasant. At the moment migration is in progress in a lot of companies, so Java code is still here to stay for a bit longer. My preference is definitely for Kotlin projects, and I would be hesitant to use Java only, having seen the benefits of Kotlin!</p><p>I ❤ Kotlin!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a0001a302dc9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Things I learned at droidcon Berlin 2018]]></title>
            <link>https://sigute.medium.com/things-i-learned-at-droidcon-berlin-2018-e014d78dde0?source=rss-de2af152264e------2</link>
            <guid isPermaLink="false">https://medium.com/p/e014d78dde0</guid>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[conference]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[droidcon]]></category>
            <dc:creator><![CDATA[Sigute]]></dc:creator>
            <pubDate>Tue, 03 Jul 2018 13:45:19 GMT</pubDate>
            <atom:updated>2018-07-03T13:45:19.688Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CjwBFzguBmYRbGLen31PSQ.jpeg" /><figcaption>Happy 10th birthday, droidcon Berlin!</figcaption></figure><p>This year was droidcon Berlin’s 10th birthday and I enjoyed three days packed with all things Android. In this post, I am sharing my experience and the things which stood out to me the most.</p><h3>Day 1</h3><p>Day 1 was barcamp-inspired. As well as talks decided on the day, there were some pre-scheduled panel discussions. I liked the room set-up, with some rooms available with traditional conference set-up, but also having a room with tables for workshops and a room with chairs in a circle for more conversation-based sessions.</p><p>The first session I attended was <strong>“Sketchnoting”</strong> workshop. This was a big hit last year, and having missed that session, I was very happy to learn this year! Looking forward to learning more things and making my sketchnotes prettier in the future.</p><h3>Sigute on Twitter</h3><p>Sketchnoting session from @miphoni and @Miqubel was great! 😄 I can&#39;t draw twitter logo! #DCBERLIN18 #sketchnoting4all inspired by last year&#39;s talk by @chiuki</p><p>It was interesting hearing the<strong> “Rx must DIE!?”</strong> panel. In my opinion RX is a nice tool, however it has big downfalls. The learning curve is very steep and for most apps it’s a bit of an overkill. As such, I would consider carefully before adding it to the app.</p><p>I also attended <strong>“Accessibility Android”</strong> session. While there was only one person in the room actively focusing on accessibility, the room was full of people wanting to improve. The discussion was mainly about vision-related accessibility, such as making sure <a href="https://www.androidcentral.com/what-google-talk-back">TalkBack </a>works, testing font sizes, making sure <a href="https://webaim.org/resources/contrastchecker/">contrast</a> is not too low, etc., as well as using the <a href="https://play.google.com/store/apps/details?id=com.google.android.apps.accessibility.auditor">Accessibility Scanner app</a> to find common issues.</p><p>We need to think about other accessibility needs as well; for example, if your app does route finding, does it have a no stairs option? How about someone using the app one-handed, is it still easy to access all the options?</p><p>If you need another reason to improve accessibility, making the app easier to use for user with accessibility needs will help every user — known as the <a href="https://medium.com/@mosaicofminds/the-curb-cut-effect-how-making-public-spaces-accessible-to-people-with-disabilities-helps-everyone-d69f24c58785">Curb Cut Effect</a>. I know I am going to push harder for making the apps I work on more accessible in the future.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/343/1*1ydE309q1-Xtnv1eV0n_YQ.jpeg" /><figcaption>sign leading to droidcon</figcaption></figure><p>The next panel was <strong>“Women in tech”</strong>, talking about recruiting, importance of diversity and how to create more diverse teams. A lot of discussion was about recruiting, however, with many women quitting tech completely, that is also an important aspect to focus on. Training managers to recognise unconscious bias was mentioned, which would be a great start. Even better, let’s educate all members of the team! A lot of focus was also on women specifically, however, members of other under-represented groups would make great additions to diverse teams and we need to have discussions about how to make sure they are included as well.</p><p>Sadly, the room was very empty compared to some other talks. It would be interesting to hear the reasons why so many conference attendees skipped this panel. The tech industry is very male-dominated and we cannot fix the problems with diversity without getting the guys involved, they should be part of the change as well, in making work environments more welcoming to everyone. However, we cannot have this discussion if the people who are needed are not even in the room.</p><h3>Day 2</h3><p>Scheduled talks started on day 2! I was really happy to find out there were two apps with the schedule as the website was very hard to navigate this year, especially on mobile. It looks like the responsive web is not there just yet and we do need native apps after all! :)</p><p>I continued with sketchnoting and the first talk I sketched was <strong>“Abstracting the map”</strong>. It’s always a good idea to abstract third-party libraries, so it’s easy to replace in case pricing model changes, etc., but, with maps, it’s often the case of apps getting very tightly coupled with the chosen map provider. Next time I am working on a map, I will use the approach I learned in this session and make sure I have an abstracted solution which will not cause headaches in case the map provider needs to change.</p><h3>Sigute on Twitter</h3><p>Great talk about abstracting the maps from @marxallski I definitely ran into issues with tightly coupled maps in the past, good to learn about solutions to this problem. Practising my sketchnoting #DCBERLIN18 #sketchnoting4all #sketchnoting</p><p><strong>“Hacking growth”</strong> was another great talk. I am looking forward to using these tips and experimenting more. One experiment at a time quickly adds up to create growth and good user experience — and you learn things you would not have considered!</p><h3>Sigute on Twitter</h3><p>Awesome tips for organic growth from @davidmonti my main things to take from this talk is to focus on quality and to experiment. #DCBERLIN18 #sketchnoting4all #sketchnoting</p><p><strong>“The curious case of Android button”</strong> — what does a button even do? Evidently, not that much! This talk improved my understanding of Android styles and I feel ready to take on creating a nice and consistent application theme! :)</p><h3>Sigute on Twitter</h3><p>Don&#39;t be afraid to deep dive! Check Android framework code to understand what&#39;s going on. My takeaway from a talk about buttons from @cortinico Also, buttons don&#39;t do that much by the number of lines of code! #DCBERLIN18</p><p>I also enjoyed <strong>“Debunking myths about the deep links”</strong> talk. I have learned some new ways to use deeplinking which I never considered before and learned about limitations.</p><h3>Sigute on Twitter</h3><p>Deeplinking used for personalised onboarding -&amp;gt; Higher user retention! From talk by @zasadnyy #DCBERLIN18</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J2Ut8SUdYswGgmyWRCVWMw.jpeg" /><figcaption>deeplinking implementations and their limits</figcaption></figure><h3>Day 3</h3><p>Day 3 started with a great keynote from GitLab titled <strong>“The best apps are built in pyjama-pants”</strong> about their process based on the way open source projects work. They have even open sourced the way their company <a href="https://about.gitlab.com/handbook/">works</a>! A lot of lessons here, especially in regards to documentation and open communication. I do believe that remote working is the future, and we need to have the right processes in place to make it happen — we can even just fork GitLab’s!</p><p>Next talk was <strong>“Common poor programming practices and how to avoid them”</strong>. Things to avoid when starting the next project for sure! Sometimes we rush to start implementing things, but taking some time to consider architecture can save so much time later on when the codebase needs to be maintained.</p><p>We also had a chance to share our thoughts about the <strong>droidcon developer community</strong>. It’s great to have a chance to give early feedback and I am excited to see what happens with this.</p><p>One of the most memorable talks of the conference was <strong>“The Authentic Developer”</strong> by Anastasia Lopez. Soft skills contribute so much to our own well-being and that of our co-workers as well. I would love to see more talks like this one in mobile conferences.</p><h3>Sigute on Twitter</h3><p>Really enjoyed a talk from @AnastasiaLopezD about being authentic developer, having compassion for others and self, and battling imposter syndrome. So much of work is about people, not code, and I have learned a few tips on how to improve at that #DCBERLIN18</p><h3>Overall</h3><p>While I have seen a lot of awesome talks, I did miss some others. It’s great that everything is recorded — I am looking forward to catching up online. With as many as 5 talks happening all at once it’s not possible to see everything, so learning is not over just yet :)</p><p>I am looking forward to applying the things I learned. I will definitely sketchnote at the conferences I go to, try to experiment more often and I would love to focus more on accessibility and great user experience in the future.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e014d78dde0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Let go of your unused code]]></title>
            <link>https://sigute.medium.com/let-go-of-your-unused-code-e90cbd7148de?source=rss-de2af152264e------2</link>
            <guid isPermaLink="false">https://medium.com/p/e90cbd7148de</guid>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Sigute]]></dc:creator>
            <pubDate>Fri, 23 Mar 2018 08:49:56 GMT</pubDate>
            <atom:updated>2018-03-23T08:49:56.862Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xw08OIcQVUpSXxX0ylz-zg.jpeg" /><figcaption>Photo by Kaboompics .com from Pexels <a href="https://www.pexels.com/photo/top-view-of-phone-earphones-pen-and-diary-6662/">https://www.pexels.com/photo/top-view-of-phone-earphones-pen-and-diary-6662/</a></figcaption></figure><p>There are many parallels to be drawn between the software development and minimalism. I have noticed that the reasons unused code keeps hanging around the software projects are the same emotional reasons which cause clutter to collect at our homes. These are the reasons I have encountered most.</p><h3>“Just In Case”</h3><p>Everyone likes to feel prepared. Some preparation is good, like a few spare batteries in the kitchen drawer. Other times, we keep items only out of fear of needing them again, even if they long lost their value. That cable which doesn’t seem to connect to any appliance you own, but might be needed, anyone?</p><p>Same with code, you might have removed a feature, but what if this code block could be useful later? And so it stays in the codebase, getting stale, generating IDE warnings. Or maybe it’s commented it out, so it would actually take some effort to even get it to compile after re-adding.</p><p>Afraid to lose something important? Tag the commit in your source control and it will be there in the unlikely scenario where you need to bring something back.</p><h3>Emotional attachment</h3><p>Some code is kept because it was hard to develop in the first place, and it would be a waste to discard something which took 3 weeks to write. Surely, it can be reused?</p><p>Maybe you did not even write it, the developer who started this project did, 5 years ago. If he/she did not remove it, then of course it must be important and will be needed any day now!</p><p>And graphic resources? You cannot lose these, they would absolutely work for some different feature, right?</p><p>Following the steps of <a href="https://konmari.com/about/the-method/">KonMari Method</a>, thank the code for the learning opportunity and then remove it from your project. If you developed it originally, that’s great, you have learned from it! If it’s so old that no one in the team remembers what it was for, it is past the time to let go.</p><h3>Resistance to change</h3><p>The following is something I have heard a few times:</p><p>“Sure, it’s not used at the moment, but it does not hurt by being there, why bother removing it? Just don’t look in that package”</p><p>But it does hurt! Especially when a new member joins the team and tries to understand the project. It’s extra mental load which can be removed easily.</p><h3>Not enough time</h3><p>Now, sure, we all want to keep our codebase nice and tidy, but we have real work to do, there are always new features to add! Who even has time to go through and remove all this old stuff?</p><p>Imagine the world where adding new features is easy because your codebase is clean and nicely structured, and start moving towards that point by including cleanup in your work flow.</p><h3>Let it go…</h3><p>Ask yourself why the old code is hanging around. Is it a rational reason?</p><p><strong>Make time to remove it and the rewards will be visible in no time!</strong></p><p>You will notice:</p><ul><li>Less logic to sift through when debugging.</li><li>Easier to find relevant code.</li><li>Improved build times.</li><li>Easier maintenance — updating a library? Now you don’t have to update that section of code which is not even used.</li><li>Easier on-boarding of new team members.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e90cbd7148de" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>