DEV Community: Susan Wangari

Deep Dive into Data Structures and Algorithms

Susan Wangari — Wed, 29 Jun 2022 20:27:35 +0000

One important thing to note is that for an algorithm to be considered effective, it should take the least time to execute and use the least amount of memory or space. There are different ways of calculating the performance of an algorithm:

Space complexity

In simple terms, whenever a solution to a problem is written, some memory is required to complete it.This is the amount of space required by an algorithm in order to execute. The input determines the space needed for execution- a larger input size means more memory is required.

Components that require space

Instruction space. This is the space required to store the executable version of the program. It is fixed but varies depending on the number of lines of code in the program. It is used to store the compiled version of instructions.

Data space. The space required to store all the constants and variables including temporary variables.

Environment space. The space required to store the environment information needed to resume the suspended function.

Calculating Space Complexity

To calculate space complexity, it is important to know the value of memory used by different types of datatype variables for example; a boolean, character and int8 have 1 byte each while float has 4 bytes.

let d = a+b+c;
console.log(d);

Variables a,b,c and d are integer types hence they will take up 4 bytes each, so the total memory will be (4(4) + 4) where the extra 4 bytes is for the console.log. This is an example of constant space complexity.

An example of Linear Space Complexity is illustrated below.

function sum (a[],n) {
  let y= 0;
  for(let i=0; i<n; i++) {
   y = y + a[i];
 }
return y;
}
sum();

In the above example, the space required is 4*n bytes for the array a[] elements. 4 bytes is then required for y,n,i and the return value. The total requirement is (4n+12) which is increasing linearly with the increase of the input value n.

Time complexity

This is the total time required by a program to run until its completion. It is estimated by counting the number of elementary steps performed by an algorithm from start to finish execution.

Time complexity is commonly expressed using the Big O Notation. This is the asymptotic(pertaining values approached at infinity) notation that represents the time complexity. Since an algorithm's performance may change depending on the input, the complexity that is commonly used is Worst-case time complexity. This is the maximum time taken for any input size.

Calculating Time Complexity

There are different types of time complexity.

Constant Time Complexity

The running time does not change in relation to the input. It is denoted by O(1) where O is Big O. This is the fastest time complexity. It is considered the best case scenario for an algorithm because no matter how big the input size is, it takes the same amount of time to execute.

Example:Array look up

let arr1 = [1,2,4,5];
arr1.index(2);

Linear Time Complexity

The running time is directly proportional to the input N. Performance grows in direct proportion to the size of the input data set. It is denoted by O(n).

Example

let arr2 = [10,20,30,40,50];
let printValue
for (let i = 0; i < arr2.length; i++) {
  let printValue += arr2[i] ;
}

The program has to loop through the array to print each element.

Quadratic Time Complexity

The running time is directly proportional to the square of the input N. It is denoted by O(n*n) or O(n^2). This is used because the complexity completes both O(1) and O(n).

Example

let text = "";
for(let i = 0; i < N; i++) {
  for(let j = 0; j < N; j++) {
    text += `The number is ${i} + ${j};`
  }
}

Logarithmic Time Complexity

The running time is proportional to the number of times N can be divided by 2. The working area is divided by 2 with each iteration. It is denoted by O(log n).

Example

function logTime(arr) {
  let numberOfLoops = 0
  for (let i = 1; i < arr.length; i *= 2) {
    numberOfLoops++
  }
  return numberOfLoops
}

let loop1 = logTime([1, 2, 3, 4]) // 2 loops

From the example above, every time the input length is doubled, the number of operations increases linearly by 1 which makes it half of the input length.

Understanding time and space complexity is important for every developer because it helps one to choose the best case to use for execution and hence ensure that the algorithm is performing at its best state while using the least memory.

Introduction to Data Structures and Algorithms

Susan Wangari — Sat, 18 Jun 2022 13:04:46 +0000

For some of us, especially those new to programming,hearing algorithms and data structures seems like a complex thing. Well, the good news is that this article will break it down in the simplest way possible.

To elaborate on what data structures are, they are containers for storing data to allow easy manipulation. Think of them as a way of organizing data so that one is able to operate. There are different types of data structures. One type is primitive data structures.These are inbuilt data structures such as int,boolean, arrays, and objects. There are also abstract data structures are defined by a set of operations and values. They include links, trees, graphs and stacks.

To define algorithms, they are a set of instructions to help you perform an operation. An example of where one would apply algorithms is in baking a cake. You prepare the ingredients and follow a step by step process to achieve a result.

There are different properties that an algorithm possesses.

They include having an input. In the cake example, the input is the ingredients used to bake the cake.
An algorithm must also have an output. In our example, the output is the baked cake.
An algorithm must have every step clearly defined. For example, define all the steps involved in baking the cake.
Every algorithm should have a defined number of steps from beginning to the end. At some point, we have to finish baking the cake.
For an algorithm to be considered effective, every step should produce a correct output. For example, we cannot follow the steps of baking a cake then produce pizza, it has to be cake.

View data structures as applicable in every area of our lives and as being used to enhance our effectiveness in performing tasks.

Short-circuiting in JavaScript

Susan Wangari — Fri, 15 Apr 2022 17:36:26 +0000

Ever heard of short-circuiting in JavaScript? It's not something strange, believe me. You might have even interacted with some parts of it at one point. Well, short-circuiting is a way of simplifying conditionals while making code more readable. In most cases, short-circuiting is utilized in place of if-else expressions. It can be used for both single and multiple if-else statements.

There are various operators used in short-circuiting. They include OR and AND. OR which is denoted by || is used to test a single condition. If one condition is right, then the code executes successfully. Check out the example below;

const response = "Foo"; const username = response || "guest"; console.log(username);
The code above checks if there is a response. If there is one, it returns the response. If not, it returns guest as the username.

AND which is denoted by && is used to test for multiple conditions. For the code to run, all of the requirements must be met. Look at the following illustration;

const response = "Foo"; const isEmailVerified = true; const username = isEmailVerified && response ; console.log(username);

This code evaluates when there is a response and the email is verified.
Both AND and OR operators can be used in one operation. For example;

const response = "Foo"; const isEmailVerified = true; const username = isEmailVerified && response || "guest"; console.log(username);
In such a scenario, the AND is executed before the OR.
There is a technique to 'override' this and allow the OR to run first. This is accomplished by the use of parenthesis. Which operators are run first are specified by parentheses. Here is an example;

const response = "Foo"; const isEmailVerified = true; const username = isEmailVerified && (response || "guest"); console.log(username);
In this case, the OR is executed before the AND operator.

In conclusion, short-circuiting should not be used as a way to shorten code but as a way to make code more readable.

Leading a Community

Susan Wangari — Wed, 18 Aug 2021 14:09:00 +0000

I look at this person and am honestly so proud of who she has become. Today marks exactly 1 year since I started leading Google Developer Student Clubs Rongo University. Back then I was too afraid to talk to people(imposter syndrome is real) because I did not feel skilled enough. I have had an amazing time getting to meet new people, hosting events, interacting with speakers and overall being part of the community.

My main win from leading this community is that I landed a role as a Developer Advocate. I am currently leading Lux Tech Academy Campus Chapters. This opportunity actually was as a result of interacting with a fellow lead who is doing great things in technology. I also got featured in an international coding series.

There have been highs and lows but all in all the journey has been one to remember. From introducing new members in the club to seeing them develop the most awesome projects. The lows have been some people giving up along the way, speakers cancelling meetups and much more but I have also seen people rise to their best selves during my tenure.

My advice to the incoming leads is, there is no formula for leading so just step in there and be awesome. Be very careful when choosing your core team because these people will be your support system throughout your tenure. Do not include your friends in the core team and do not rely on their support; they will always disappoint you.

My special shout out goes to Muhammud Samu(Auwal) for his unending support and encouragement throughout my tenure. My special thanks also goes to our new GDSC lead Derrickson Ndambuki. This guy never missed an event and was always there to help. Shout out to you Harun Mwendwa for believing in me. I look forward to working with you more.

I look forward to what this community will achieve in the future. Cheers to more wins and to making the world a better place through technology and collaborations.

Zuri Training

Susan Wangari — Fri, 26 Mar 2021 10:10:11 +0000

So...here we are. I saw a post on twitter one day about a training that would take place with Zuri in partnership with Ingessive4Good and HNG all over it and decided, 'why not try this? you never know'. Getting that welcome email was the most exciting part for me because I never thought I would be accepted. I am all in it to learn and gain the most because who knows when such an opportunity will come by again.

We are still working on our first task of creating a CV and uploading some links but am super excited and looking forward to the whole process. Each task has a period of 2 weeks to complete it so as to accommodate those who are not always online. The tasks so far are also very friendly.

We have started our classes with links being uploaded on YouTube and on zuriboard. We also have awesome resources coming our way. The best part is the mentors. Ever had of patient people, because these ones are super patient and always ready to assist.

I will keep in touch about the whole process but for now, that's all from me. Chao!!

JavaScript Array Methods

Susan Wangari — Fri, 07 Aug 2020 20:47:17 +0000

For those of us new in programming, arrays may not be so familiar.No worries, we shall dive right into it.

So what is an array?
An array is a collection of one or more elements of either the same type or different types.The length of an array is not limited.It lets you store multiple elements in a single variable.The elements can be strings, numbers or boolean.
Example
let myArray = ["A", "B", "C", 12, true];
//shows an array with 3 strings, 1 number and a boolean value

Array Methods

Every method in an array causes an impact; it changes the array in one way or another.We will look at 3 array methods.These are: map, filter and reduce.

1.map() or Array.prototype.map() creates a new array with the results of calling a function for every array element.It does not change the original array.
Example
let myNumbers = [20, 21, 22]; let myArray = myNumbers.map(multiply = (num) => num * 2); console.log(myArray);
//myArray returns 40, 42,44

2.filter() or Array.prototype.filter() creates a new array containing only the elements for which the filtered function returns true.It also does not mutate or change the original array.
Example
const names = ["Susan", "Jane", "John", "Tom"]; const newNames = names.filter(names => names.length < 5); console.log(newNames);
//newNames returns ["Jane", "John" and "Tom"]

3.reduce() or Array.prototype.reduce() as the word suggests, it reduces an array to a single value.This is achieved using a callback function that is called on each iteration.
A *callback function is a function that is passed as a parameter to another function.*It is run inside of the function it was passed into.A callback function accepts 4 arguments.The 1st argument is the accumulator which gets assigned the return value of the callback function from the last iteration.The 2nd argument is the current value which is the current element being processed in an array.The 3rd argument is the index of the current element and the fourth argument is the array upon which reduce() is called upon.The 3rd and 4th arguments are optional.
A perfect example of where reduce can be used is in adding the elements of an array.
const ourArray = [5, 6, 8]; const reducer = (accumulator, currentValue) => accumulator + currentValue; console.log(ourArray.reduce(reducer));
//this code returns 19

Its a wrap.I hope we have all learnt how to apply array methods map, filter and reduce.

Principles of Object Oriented Programming

Susan Wangari — Mon, 13 Jul 2020 18:06:23 +0000

Object Oriented Programming involves using objects to model real world things that we want to represent inside our programs.
An object is an instance of a class that has methods and properties.
A class is a blueprint of an object.Classes can have many objects.
Let's take a look at the Principles of Object Oriented Programming
1.Encapsulation
This involves enclosing or hiding something.In an object,the methods and properties are enclosed within the object.An object keeps its state private, inside a class.Other objects don't have direct access to this state.To communicate with the object, you should use the methods provided but you cannot change the state of the object.
for example
class bird {
constructor (name, legs) {
this.name = name;
this.id = id;
}
add_Friends(add) {
this.add = add;
}
getDetails() {
console.log(Name is ${this.name}, Friends is ${this.add});
}
}
let bird1 = new bird("Hooky", 2);
bird1.add_Friends("Batu");
bird1.getDetails();
2.Abstraction
It involves hiding complex details and showing simple ones.It helps code to be more understandable.
for example
function man (fName, lName) {
let firstName = fName;
let lastName = lName;

let getDetails_noaccess = function() {
return (My first name is ${firstName}, my last name is ${lastName});
}

this.getDetails_access = function() {
return (My first name is ${firstName}, my last name is $ {lastName});
}
}
let man1 = new man("Samson", "Tunny");
console.log(man1.firstName);
console.log(man1.getDetails_noaccess);
console.log(man1.getdetails_access());
3.Inheritance
It is gaining something from someone else.In Object Oriented Programming, it allows for parent class to pass functionality to a child class hence avoiding repeats.It uses extends to create a subclass of the object.
for example
class person {
constructor(name) {
this.name = name;
toString() {
return (The name of this person is ${this.name}); } } class student extends person { constructor(name, id) { super(name); this.id = id; } toString() { return ({super.toString()}, Student ID is ${this.id}`);
}
}
let student1 = new student("Nyota", 20);
console.log(student1.toString());
4.Polymorphism
It is something having multiple forms.In Object Oriented Programming, it involves the same method being used on different objects. Polymorphism gives us the ability to call the same method on different objects.Each child keeps its own methods as they are.
for example
class A {
display() {
console.log("A is invoked");
}
}
class B extends A {
display() {
console.log("B is invoked");
}
}
let a = [new A(), new B()];
a.forEach(function(msg) {
msg.display();
});

Conclusion
These principles are what make JavaScript to be an Object Oriented Language.All these principles are meant to create a better understanding and increase the usability of objects.They also help reduce repetition of code hence leading to clean code.

Diving into Object Oriented Programming

Susan Wangari — Fri, 10 Jul 2020 06:04:56 +0000

Just like the title,Object Oriented Programming is all about objects.Objects have properties and these are what makes an object.One thing to note is that objects can share properties but have different values for those properties.

Properties in an object can be accessed in 2 ways:

-using dot notation

for example

let duck = {
name: "Aflac",
numLegs: 2
};
console.log(duck.name);

-using bracket notation

for example

let duck = {
name: "Aflac",
numLegs: 2
};
console.log(duck[name]);

Objects have constructors.Constructors are functions that create new objects.They use this keyword to set properties of the object they will create.They are defined with a capitalized name to distinguish them from other functions that are not constructors.Objects properties created with constructors are separated with a semicolon unlike other object properties which are separated with a comma.new operator is used when calling a constructor.

for example:

function Bird() {
this.name = "Albert";
this.color = "blue";
this.numLegs = 2;
// "this" inside the constructor always refers to the object being created
}

let blueBird = new Bird();
When a constructor function creates a new object,it is an instance of its constructor.instance of allows you to compare an object to a constructor.It returns true if the constructor created the object and false if the constructor did not create the object.

for example:

let Bird = function(name, color) {
this.name = name;
this.color = color;
this.numLegs = 2;
}

let crow = new Bird("Alexis", "black");

crow instanceof Bird; // => true
prototype properties reduce code duplication.They are shared among all instances of an object.

for example:

Bird.prototype.numLegs = 2;
console.log(duck.numLegs); // prints 2
console.log(canary.numLegs); // prints 2
Using Bird.prototype ensures that you do not have to define numLegs is not defined in both duck and canary.

Objects have methods.One of these methods is Object.create().

for example:

let animal = Object.create(Animal.prototype);