DEV Community: Collins Etemesi

Android Activity Lifecycle

Collins Etemesi — Sun, 04 Feb 2024 18:07:20 +0000

In an Android app, the Android system uses activities to run code. The activity lifecycle is the different states that an activity can go through, from when the activity first initializes to its destruction.

The Activity class provides 7 callback methods that let the activity know when a state changes: onCreate(), onStart(), onResume(), onPause(), onStop(), onRestart(), onDestroy().

onCreate()
The onCreate() lifecycle method is called once, just after the activity initializes—when the OS creates the new Activity object in memory. After onCreate() executes, the activity is considered created.

onStart()
The onStart() lifecycle method is called just after onCreate(). After onStart() runs, your activity is visible on the screen to the user. Unlike onCreate(), which is called only once to initialize your activity, onStart() can be called by the system many times in the lifecycle of your activity.

onResume()
This method is called when the activity will start interacting with the user. The user starts interacting with your app for this to happen.

onPause()
Always called after onResume() and when the user is no longer actively interacting with the activity but the activity is still visible on the screen.

onStop()
This is called when the activity is no longer visible on the screen to the user.

onRestart()
Called when the current activity is being redisplayed to the user. From the Stopped state, if the activity comes back to interact with the user the system invokes onRestart().

onDestroy()
is called before the activity is destroyed. The system invokes this callback either because, the user dismisses the activity, or there is a configuration change such as device rotation.

Thank you for reading this article. Happy Coding.

Modern JavaScript for everyone: Mastering Modern JavaScript The Right Way

Collins Etemesi — Fri, 04 Mar 2022 08:37:37 +0000

Introduction
JavaScript is a scripting language you can use to make web pages interactive. To write javascript code you need a code editor.

Code Editor For JavaScript
A code editor is a text editor also designed to help you write code. A code editor is one of the essential tools for programmers designed to edit the source code of computer programs. For javascript I recommend using Visual studio code.Download visual studio

JavaScript can be written in two ways in your HMTL code:
Internal Javascript
A JavaScript function is placed in the <body> section of an HTML page

<html>
<body>
<script>
function myFunction() {
  document.getElementById("demo").innerHTML = "Paragraph changed.";
}
</script>
</body>
</html>

External Javascript
Scripts can also be placed in external files. External file: myScript.js
function myFunction() { document.getElementById("demo").innerHTML = "Paragraph changed."; }
External scripts are practical when the same code is used in many different web pages. JavaScript files have the file extension .js. To use an external script, put the name of the script file in the src(source) attribute of a <script> tag:
<script src="myScript.js"></script>

Modern Javascript concepts
Some of the javascript concepts that this article will cover include:

Variables
Objects
Promises
Classes

Variables
To declare a variable in JavaScript, there are three keywords available, each with its own set of peculiarities. var, let, and const are the three variables.

console.log(myNum); //undefinedvar myNum = 5;
function myFunc() { let myFunc = 'Mary';
const person = { name: 'Mary' };
Objects
In JavaScript, an object is a standalone entity, with properties and type. They include: string, number, boolean, null and undefined. For example a user object can have the following properties: username, email and gender.
You can define a property of an object by assigning it a value. To demonstrate this, here’s a sample object myDog
const myDog = { “name”: “Joe”, “legs”: 4, “tails”: 1, “friends”:[“everyone”] };
Promises
In JavaScript, promises are the most prevalent approach to handle asynchronous tasks. A promise established in JavaScript is primarily built on the idea that when the time comes, it will either be resolved or rejected. A promise exists in the following three states:

Fulfilled - the promised task was completed successfully.
Rejected - the promised task was not completed or is unsuccessful.
Pending - the promised task has neither been fulfilled nor rejected. Example:

function work() {
    return true;
}
const myPromise = new Promise((resolve, reject) => {
    let isopen = work();

    if(isopen === true) {
        resolve('Shop is open!')
    }
    else {
        reject('Shop is closed now!')
    }
});

myPromise.then((order) => {
    console.log(order);
}).catch((order) => {
    console.log(order);
});

Classes
ECMAScript 2015, also known as ES6, introduced JavaScript Classes. A JavaScript class is just a template for constructing objects.
Example
class Car { constructor(name, year) { this.name = name; this.year = year; } }
When you have a class, you can use the class to create objects. The example below uses the Car class to create two Car objects.
let myCar1 = new Car("Ford", 2014); let myCar2 = new Car("Audi", 2019);
Conclusion
That brings me to the end of my article; I hope it explains modern javascript in a way that you have understood. Happy Coding.

Introduction to Data Structures and Algorithms With Modern Javascript

Collins Etemesi — Mon, 21 Feb 2022 12:01:40 +0000

What is Data Structure and Algorithms
A data structure (DS) is a way of organising data so that it can be used effectively.
An algorithm is a series of step-by-step instructions that describe how to do something.

Why Data Structures and Algorithms are important

Learning data structures will help to write clean and consistent code.
Effective algorithms helps to break a problem down into smaller parts and think carefully about how to solve each part with code.

This article will go through a list of following Data Structures and Algorithms: Arrays, Queue, Stack, Linked list.

Arrays
An array is a special variable, which can hold more than one value.
Using an array literal is the easiest way to create a JavaScript Array.
const array_name = [item1, item2, ...];
Example:
const snacks = ["Ice cream", "Nuggets", "Popcorn"];
Operations available in an array include:

Accessing Array Elements
Changing an Array Element
Looping Array Elements
Adding Array Elements

Queue
A queue is an ordered list of elements where an element is inserted at the end of the queue and is removed from the front of the queue. A queue works based on the first-in, first-out (FIFO) principle, which is different from a stack, which works based on the last-in, first-out (LIFO) principle.
A queue has two main operations:

Enque. Insert a new element at the end of the queue.
Dequeue. Remove an element from the front of the queue. Enqueue

enqueue(element){
         this.items[this.count] = element;
         this.count ++;
     }

Dequeue

dequeue(){
         if (this.isEmpty()) {
             return undefined;
         }
         let result = this.items[this.lowestCount]; 
         delete this.items[this.lowestCount]; 
         this.lowestCount ++; 
         return result; 

     }

Stack
Stack is a linear data structure in which addition or removal of element follows a particular order i.e. LIFO(Last in First Out) AND FILO(First in Last Out).
The following is an example of a stack class using array:

// Stack class
class Stack {

    // Array is used to implement stack
    constructor()
    {
        this.items = [];
    }

    // Functions to be implemented
    // push(item)
    // pop()
    // peek()
    // isEmpty()
    // printStack()
}

The following is a list of operations available in implementing a stack

Push : Insert an element.
Pop : Remove an element
Peek : Get the topmost element.
Size : Get size of the stack.
isEmpty : Check if the stack is empty if empty return true else false.
Clear : Reset the stack.

Linked List
A linked list is a linear data structure where each element is a separate object that contains a pointer or a link to the next object in that list. Each element (commonly called nodes) contains two items: the data stored and a link to the next node.
The following an example of a Linked List Node:

// User defined class node
class Node {
    // constructor
    constructor(element)
    {
        this.element = element;
        this.next = null
    }
}

List Of Operations Available in linked list

Push: Insert an element at the end of the linked list.
Insert: Insert an element at the given index of the linked list.
Remove: Remove the end element of the linked list.
RemoveAt: Remove the element at the given index of the linked list.
GetElementAt: Get the element at the given index of the linked list.
IndexOf: Return the index of the element in the linked list.

Conclusion
Data structures will help to write clean and consistent code and algorithms helps to break a problem down into smaller parts and think carefully about how to solve each part with code. Some of these data structures and algorithms are: Arrays, Queue, Stack, Linked list. I hope this article has introduced them to your understanding and satisfaction.

Javascript Objects

Collins Etemesi — Fri, 11 Feb 2022 22:51:53 +0000

Javascript works on the basis of object oriented programming. This article describes how to use objects, properties and methods, and how to create your own objects.

What is an object?
In JavaScript, an object is a standalone entity, with properties and type. They include: string, number, boolean, null and undefined. For example a user object can have the following properties: username, email and gender.

Objects and properties
A JavaScript object has properties associated with it. A property of an object is a variable that is attached to the object. The properties of an object define the characteristics of the object. You access the properties of an object with a simple dot-notation:
objectName.propertyName
Like all JavaScript variables, both the object name and property name are case sensitive.
You can define a property by assigning it a value. To demonstrate this, here’s a sample object myDog

const myDog = {
“name”: “Joe”,
“legs”: 4,
“tails”: 1,
“friends”:[“everyone”]
};

“Name”, “legs”, “tails” and “friends” are properties while “Joe” “4” “1” and “everyone” are values.

Object Methods
Methods are actions that can be performed on objects.

const person = {
  firstName: "John",
  lastName: "Doe",
  id: 5566,
  fullName: function() {
    return this.firstName + " " + this.lastName;
  }
};

Creating a JavaScript Object Using an Object Literal
This is the easiest way to create a JavaScript Object.
Using an object literal, you both define and create an object in one statement.
const person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};

Conclusion
Objects in JavaScript can be compared to objects in real life. The concept of objects in JavaScript can be understood with real life, tangible objects. In JavaScript, an object is a standalone entity, with properties and type. Compare it with a chair, for example. A chair is an object, with properties. A chair has a color, a design, weight, a material it is made of. The same way, JavaScript objects can have properties, which define their characteristics.