DEV Community: Samuel Ochuba

Your Users Will Do the Darnedest thing: Hedging Against That as a Mobile Developer.

Samuel Ochuba — Wed, 30 Aug 2023 22:20:42 +0000

As I sit on my bed, struck down with malaria, trying not to work and not to work at the same time, I am reminded of the consequences of underestimating mosquitoes. (For those who don't know, mosquitoes are the vectors of malaria.) This got me thinking that there is something else in the mobile world that is underestimated but is the biggest source of user-perceived bugs: bad UX. I decided to write a quick article on it and share my perspective.

You resume work on a calm Monday morning. Less than two hours later, Slack is buzzing. Customer service is forwarding a common complaint from users about some strange bugs happening in the app. No one, including them and the QA team, seems to be able to reproduce the bug. It's a big conundrum. You try to replicate it, but you also hit the same snag. You decide to hope and pray that this issue goes away. But annoyingly, this problem seems to arise at intervals.

I'm guessing this is a common situation in many companies. The reason is that you can never fully test the ways users will use your app. It will be used by thousands, if not millions, of consumers on different devices in different conditions. Your app will be pressed by angry people, busy people, sad people, happy people. It will be virtually impossible for you to test all the different flows that can happen when your app is used.

This article is not meant to discourage you. It is just meant to share, to the best of my limited experience, things you could do to prevent strange bugs.

The most important thing is to have robust validations. For each input field in your app, are you sure that the correct format is inputted before the data is sent for processing? Many mobile devs leave validations only for the login and signup phases of the app. However, it is important for it to be used everywhere your app allows your user to input data. Remember, validation without a clear message is not the correct way. A clear message telling the user why the input is wrong is better than no message at all. Also, using the correct input field for either numbers or emails is the proper way to go.

Your users are impatient. Don't think that the user will just click that button and wait for its outcome. Also, for users with slow devices, the effect of clicking a button might not be immediately apparent. You want to make it impossible for the user to double-click a button until the outcome of the button click is returned. Either disable the button or cover the screen with a dialog. In all cases, you cannot prevent this. But you need to also be sure that double-clicking of that button does not cause an unexpected bug or a bug.

Your users will pause what they are doing on the app and navigate to another app temporarily, then come back. Are you handling for that exact scenario? For Android developers, does Android's aggressive memory management cause unexpected bugs for you? Have you simulated what could happen in these scenarios? And can your app live with the consequences of Android's aggressiveness?

Your users will not navigate the app the way you want them to. They will ignore that back button you provided for them and click on the system back button. Are you properly shepherding them to the page you want them to go to no matter where they navigate to?

Who knows? I might make this a longer series with each one dedicated to a particular war story. Or it might go the way of the majority of my stories: forever in my drafts.

shout out to Nubison for the image

Android Workmanager: Implementation, Tips and Pitfalls to Avoid (1)

Samuel Ochuba — Tue, 07 Feb 2023 17:19:23 +0000

For over a year i have been interacting with the android Workmanager Api . A very powerful api, I resolved to publish some articles around what I have been building and this is the first in the series.

You have been presented with a situation. The business wants all interactions and flow happening in the app to happen offline and whenever the user's internet is turned on synchronise that data to the backend. You do your research and you come across a powerful API in android called Workmanager and you start building. The aim of this article is to give a short tutorial on workmanager as well as give tips on how to avoid potential catastrophic events that could lead to issues later on.

Workmanager is fantastic when you want to schedule work to be done sometime in the future with some constraints. Take for example, in the example given above, the constraint is internet access. Workmanager gives you the ability to specify the conditions that should be met before your work begins.

Let us declare a workmanager class called ScoresAverageWorker this class syncs all the attendance results taken by a teacher for their class.

The first thing you want to do is to create the Workmanager Class

class ScoresAverageWorker(
    context: Context,
    workerParams: WorkerParameters
) : Worker(context, workerParameters) {

override fun doWork(): Result {

if (work is successful) {

return Result.success()

} else {

 if (work needs to be retried) {
     // try again if there is a server error

 return Result.retry()
     }
 return Result.failure()
     }
     }
}

this class extends the Worker class and takes in two parameters, which are context and worker parameters. Worker parameters refer to data you might need to do work. we will talk about it later, for now let us focus on other aspects.

The above class overrides a function called doWork and that is where the work we would like workmanager to perform gets done. This function returns a Class Result

The three different methods you can return from the class are Result.success() , which indicates that the work was successful. Result.failure() which indicates that the work was not successful and Result.retry() which tells Workmanager to retry the work.

Now that we are done setting up the workmanager class. we can now move ahead to figuring out how to instantiate it. You can determine how periodically you want your work to occur, either once or at intervals.

In this article, we would stick to only one-time work requests. To start a one-time work, we need to first instantiate our workmanager class, then use OneTimeWorkRequestBuilder to build our request.

val workManager = WorkManager.getInstance(this)

val scoresAverageWorker: OneTimeWorkRequest =
    OneTimeWorkRequestBuilder<ScoresAverageWorker>()
        .setInitialDelay(5, TimeUnit.SECONDS)
        .build()


workManager.beginUniqueWork("Unique_Work_Name", ExistingWorkPolicy.REPLACE, scoresAverageWorker).enqueue()

The above code instantiates a one-time work request builder, sets an initial delay of 5 seconds to it and begins a unique work.

The second part of this series will focus on how to send data to our workmanager class and how to create a coroutine worker.

Understanding OOP Concepts With Kotlin

Samuel Ochuba — Tue, 06 Jul 2021 14:04:17 +0000

You just finished learning variables in kotlin and you are wondering how do they come together to create complex amazing programs you have read about. This article will introduce you to the concepts of object oriented programming in a simplified way. We will use practical examples to explain how Complex methods are created. So let us dive right in

First of all we need to understand what Object oriented programming(OOP) is. OOP relies on the concepts of classes and object. it is a way we use to structure our software program into simple pieces that can be used multiple times.

This brings us to another question . What are classes? . A class is a blueprint that is used to create more specific objects. Let us take the case of an architect.

An architect has a blueprint for how he wants a building to look like. From that blueprint multiple buildings can be built. Each of the building can have a unique name and properties, but they all share the same fundamental features

Let us use a real life example to explain OOP concepts. Let us use the example of a school. Imagine you were awarded the contract to write an application for a school. The aim of the application is to make the school more productive.

Your application will allow the principal admit students, a student can take multiple courses, a teacher can teach a course.. etc.

Creating a program this complex would require a lot of code. Your school could have thousands of students and it would be terribly inefficient to write unique code for each of the students. We could create a class called student in kotlin



class Student(){
}

Each of the student could have properties, which can include a name, age, class etc..
In kotlin properties of class can be declared in the primary constructor using this format



class Student(name: String, age:String , class:String){
}

By creating a student class we can create multiple students. In this instance the multiple students are instances of the student class. i.e types of the student class. They are called objects. In kotlin objects are instantiated this way



var samuel = Student("samuel", 23, "Grade 5")

Samuel which is an object of the student class has three attributes. which are his name, age and Grade.

Attributes are information associated with a class . sometimes it will be necessary for a student to perform some actions like take a course or take examinations. In kotlin methods are declared this way



fun takeCourse(course:String){
}

A method can take in information and perform an action. it can also return information



fun takeCourse(course:String): Boolean{

return true
}

Now let us explore the four principles of OOP

Inheritance
Encapsulation
Abstraction
Polymorphism

Inheritance

Inheritance is a feature in OOP that allows classes to inherit from other classes. Inheritance supports reusability. it reduces the number of boilerplate code that needs to be written. Let us use the case of our school project. The different roles in a school. i.e teachers, principals, students. etc are all human beings. so they all need to have a name, age etc.

if we were to use that model this scenario in kotlin we would need to first create a class person and make student, principal and staff class inherit from it.



open class Person(name:String){
}

class Student(name:String): Person(name){
}

In the code snippet above class student inherits the name attribute from the Person class



open class Person(name:String){
open fun dance(){}
}

class Student(name:String): Person(name){
override fun dance() {  }
}

You can also override methods used in the parent class

Encapsulation

Encapsulation is the art of hiding important information from other classes and exposing them only through a select method. Imagine the requirements of our app dictates that the principal should only be able to see the list of all students and add students to the list. we would have to look for a way to make that happen. That way is called encapsulation.



class Principal(){
 private var studentsName = mutableListOf<String>()


fun getStudentsName(): List<String>{
  return studentsName
}

The names of the students have been hidden and can only be gotten through the getStudentsName method. The only way it can be modified is only within the class. We can achieve encapsulation through the use of visibility modifiers

Abstraction

Abstraction means that the user can only interact with select attributes and methods of an object. In our case if a principal admits applicants and makes them students. An outsider does not care how the principal goes about it. The other parts of the program would only want to get the students or pass the applicant to be converted to students. If there is a complex operation ongoing in the principal class that changes an applicant to student, other parts of the program do not care about it.

Polymorphism

This refers to the art of designing objects to share behaviour either through method overloading or method overriding.

In kotlin these are achieved through the following syntax



fun admitApplicant(applicant: String){
}

fun admitApplicant(applicants: List<String>){
}

From the code both methods can be named similarly but the method that gets called is dependent on what you passed in as a parameter in this case one method takes a string while the other takes in a list of string.

If all users in our school application can delete themselves from the database. That means in our Person class there would be a method called delete



open class Person(name:String){
open fun delete(){}
}

class Student(name:String): Person(name){
override fun delete() { 
  //students can delete themselves from the database
 }
}

Learning object oriented programming is a continous process that never ends in the life of a developer. Each program you would write during the course of our career would require you to think deep on how best to implement it keeping OOP principles in mind.

If you have any observations or questions you can reach out to me on twitter @rake_code

How to add a remote Github repository to local

Samuel Ochuba — Thu, 01 Jul 2021 01:44:37 +0000

You might have been given a task to accomplish using github classrooms or created a remote repository on github and you are wondering how to push your local project to the remote repository. In this article i will quickly show you how to accomplish that task. Sit tight.

On the terminal of your ide . you will want to initialize the local directory as a git repository by using this command.

git init -b main

This command converts your local repository into a git repository. The next thing you would want to do is add the files you have in your local repository into your git repository by committing them. Before committing the files you would first have to add them . The command for adding is below

git add .

After adding the files you then commit it to the local git repository by using the command:

git commit -m "First commit"

First commit represents the commit message. it is usually a short title that is an overview of what you have done. This local commit also prepares the files to be pushed to a remote repository.

At the top of your github online repository setup page you would see the repository url . either HTTPS or ssh. depending on your organization's requirements

You would need to add the url you have copied to your local github repository by using the below command.

git remote add origin  <REMOTE_URL>

Then verify the remote url

git remote -v

After adding the url to the local github repo. You can then push your changes to your online repo by using the below command

 git push -u origin main

With main being the name of the branch online you are pushing your local changes to

Thank you very much and i hope this article helps you with your first steps in github. I am always free to answer questions and help. you can check my profile out on twitter
@rake_code

You Could Write Simpler Code in Android: Monitoring Changed Text in An EditText Field

Samuel Ochuba — Fri, 27 Nov 2020 01:57:11 +0000

While working on my recent project, several times while trying to implement a feature I came across several articles online whose code advocated writing long lines of code. This could be as a result of the articles being written a long time ago(In android, a long time could be as short as six months). This informed my choice to create a series where I highlight simpler ways of writing code than the ones commonly available online when using ktx extensions.

This article is going to be a short one just to illustrate how much fewer lines of code you could write. A particular scenario you might be faced with is getting the changing text when a user inputs value into an edittext field. The situation might also mean you want a particular event to occur anytime the text in the field changes.

To accomplish this task, a cursory search on google might take you to a stackoverflow page where the top three answers may look like this one:

Or this one:

After seeing these answers you get the feeling that you are writing a lot of code just to get the text that was changed or to be notified when the text changes. Don't worry I get the feeling. I had the same exact feeling

I discovered that it could be accomplished with just three lines of code. A call to the doOnTextChanged was enough to do my bidding.

My next article would be on Navigation drawer stay tuned

I Just Created a spinner with Android Material Design. Let me share my pains with you

Samuel Ochuba — Sat, 21 Nov 2020 18:03:12 +0000

The task was to create a spinner item to display a list of banks for users to select. I decided to use the material design spinner to accomplish the task. This was the first time I would use material design spinner but I didn't worry about the limited timeline of my sprint because I expected it to be an easy thing to do, Considering I had used Material design components multiple times. My first point of call was google's material design website. The result included progress bars, menu etc, but nothing on spinners. I was shocked that a very common UI component like spinner wasn't available in material design.

Not wanting to believe that possibility, I decided to do a google search on how a material design spinner in android could be implemented. One of the very first articles I came across was hilarious and made my already souring mood to cheer up a little. if you are interested in a little laugh you can read the article here

After reading the article i found out that google decided to call a spinner in android material design an Exposed Dropdown Menu. If not for that article I would never have found out or I would have done a considerable search before finding out what exactly a spinner is called in material design.

Because Exposed Dropdown Menu isn't exactly a spinner, you are forced to think in terms of a spinner but code in terms of a TextInputLayout. Good luck finding relevant materials as a dev on material design spinner (it took me over 30 minutes to figure out how to get a user's selected item).

All I Was Trying to Accomplish

Battle 1: Setting a background colour to the spinner

Setting the background color in most UI components mostly involves just using the "android:background" attribute i.e.

android:background="@color/black"

I was pleasantly suprised that it didn't work as intended i decided to do a little digging and found out that the appriopate attribute to use was

 app:boxBackgroundColor="@color/black"

Battle 2: Setting a Stroke Color

As an android developer especially a junior one or a beginner, Most of the times you get to customize an edittext field or button, It is usually done by creating a drawable xml file and setting the background of the view to the xml drawable. It doesn't work that way on a material design spinner aka Exposed Dropdown Menu.
After trying out all the usual ways with ever-increasing frustration. I decided to take a chilled coke and think up another way I could do it. it is amazing what a chilled coke could do to the brain in terms of inducing a eureka moment.
I decided to use themes to colour the stroke and unsurprisingly it worked. It just involved me creating a style like this

Then i set the style of my TextInputLayout to:

       style="@style/spinnerTheme"

Battle 3: Setting the Spinner Dropdown Icon and Getting the Selected Item

After winning the first two battles, I felt confident that the next battle would be the easiest of the three. I was wrong in that aspect. Setting the icon drawable meant I had to go through all the suggested properties android studio offered me before I found out that the endIcon attribute was the attribute I had to change.
Once i found out it was just a matter of overriding it in my themes.
My completed style is below:

The path to finding out how to get the user-selected item took quite some time than i estimated.. over 15 minutes. In a normal android spinner, overriding onItemSelected Material design spinner ..coughs* .. Exposed Dropdown Menu doesn't work like that. After a little search, i found out that onTextChanged listener could work for it. But to me, it felt like an over kill since I was just looking to get the user selected bank.
After a deeper search, I found out that AutoCompleteTextView was a child of EditText. Going along with that reasoning i hypothesized that the getText() method would work in getting the selected item. it worked!!.

   var bank = spinner.editText?.text.toString

Though my solution seemed to work I am still anticipating bugs.

I decided to post this article to add some material and help some other junior dev or beginner who might have the fortune to navigate the material design spinner maze. Articles on Material design spinner seemed scarce online.