DEV Community: Bola Adebesin

JavaScript: Linked Objects

Bola Adebesin — Fri, 14 Mar 2025 17:47:20 +0000

Recently, I've been working to understand JavaScript better with the goal of evolving how I write code, communicate ideas, and build stuff.

I've often heard something to the effect of, "JavaScript has classes, but it is not a class-based language". Along with the implication that, the use of classes "bends" the language rather than accepting it for what it is.

This felt like information that could be true, but that I didn't understand because...well JavaScript has classes. And it was my first language. I didn't come up learning Java or even complete a traditional computer science program at a four year institution.

Eventually, I was exposed to more information about JavaScript's Object.prototype. This great, ancestral object sits at the top of the prototype chain passing on properties and characteristics to other objects. Things started to become a little clearer, but also still kind of confusing. Prototypal inheritance sounded cool, but it felt like a distinction without a difference.

Then, I watched this workshop by Kyle Simpson the author of the You Don't Know JavaScript series. He demonstrated a way of linking objects together without using the new keyword or the syntactic sugar that is class.

I was intrigued. I wanted to try it. I also wanted to apply more of what I've been learning. So I wrote some logic for generating different types of tasks using the factory pattern and linked objects.

var TaskType = {
    TODO: "To Do", 
    IN_PROGRESS: "In Progress", 
    COMPLETED: "Completed"
}

var Task = {
    logTaskInfo(){
        console.log(`Title: ${this.title} | Details: ${this.details} | Status: ${this.status}`)
    }
}

function TaskFactory(){
    return createTask; 

    function createTask(type, title, details){
        var isInvalidType = !Object.values(TaskType).includes(type); 
        if(isInvalidType){
            throw new Error('Invalid Task Type')
        }
        return Object.assign(Object.create(Task), {
            title, 
            details, 
            status: type
        })
    }
}

var factory = TaskFactory(); 

var task1 = factory(TaskType.TODO, "Wash Dishes", "Load the dishwasher and scrub large pots and pans."); 
var task2 = factory(TaskType.IN_PROGRESS, "Write Code", "Apply newly acquired concepts like IFFE, Factory and OLOO"); 
var task3 = factory(TaskType.COMPLETED, "Walk Dog", "Take Soleil out for her morning walk."); 

task1.logTaskInfo(); 
task2.logTaskInfo(); 
task3.logTaskInfo();

From TC39, Object.assign ( target, ...sources ) copies the values of all of the enumerable own properties from one or more source objects to a target object. And Object.create ( O, Properties ) creates a new object with a specified prototype.

So, with these lines of code:

Object.assign(Object.create(Task), {
            title, 
            details, 
            status: type
        })

Object.Create(Task) creates a brand new object and links it to the existing Task object. And that brand new object is assigned a title, details, and a status.

Now, when task1 invokes logTaskDetails it works because logTaskDetails exists on the object that task1 is linked to.

Okay, "pretty cool", I thought. You could make the argument that this approach is more explicit than using something like the new keyword, but what's the big deal? But then things got really interesting.

This style becomes the foundation for behavior delegation or "dynamic composition". Where objects with different concerns are linked together and can share methods. It's less top-down and more peer-to-peer.

Here is an example Simpson presents with an AuthController and a LoginFormController:

var AuthController = {
    authenticate(){
        server.authenticate(
            [this.username, this.password], this.handleResponse.bind(this)
        )
    },
    handleResponse(resp){
        if(!resp.OK){
            this.displayError(resp.msg); 
        }
    }
}

var LoginFormController = Object.assign(
    Object.create(AuthController), 
    {
        onSubmit(){
            this.username = this.$username.val(); 
            this.password = $this.$password.val();
            this.authenticate() 
        }, 
        displayError(msg){
            alert(msg)
        }
    }
)

I thought this was a really cool example, although I had to read through the code a few times to understand what was happening.

Here, the same way that task1 was linked to the Task object, LoginFormController is linked to AuthController. When an imaginary login form is submitted, LoginFormController's onSubmit method is called. Inside onSubmit the authenticate() method is called.

LoginFormController doesn't have an authenticate method, but the object it is linked to (AuthController) does. So, the method runs with this still referring to LoginFormController. Inside authenticate, this.username and this.password are still referring to values on LoginFormController and are passed to the server along with the callback handleResponse. Now, handleResponse is bound to LoginFormController with .bind as it is passed to the server. So whenever it is called, it will also be referring to LoginFormController even though that isn't where it was defined. When handleResponse is invoked, if the response was not okay, then it will call the display method. display has a this that references LoginController because that was the this handleResponse was bound to.

So, in summary, onSubmit which is defined in LoginController calls authenticate a method defined in AuthController. authenticate passes a callback, handleResponse, which is defined in Authcontroller, but bound to LoginController. And handleResponse calls display which is defined in LoginController.

This logic requires a strong understanding of this (no pun intended). And even though I think it's pretty cool, given this task, I would not have thought to structure the code this way. It's a very different way of thinking than I'm used to.

A classic case of, "the spirit is willing, but the flesh is weak". I'm going to keep working at it though.

In the meantime, please let me know what you think. Is this a style you have used or are interested in using? How do you think the code fares as far as readability?

Image by Alltechbuzz_net from Pixabay

Writing Human Readable Code: To Name or Not To Name

Bola Adebesin — Sun, 23 Feb 2025 23:07:20 +0000

I waffled back and forth about the title of this post, but in the end, I couldn't resist the Hamlet reference.

Today's topic is about writing clear, human-readable code. I care about this for a few reasons. When code is easier to read/understand, it's easier to:

Maintain
Refactor
Discuss (with clients, colleagues, your rubber duck etc).

There are so many instances where I've come across old code that I don't understand.

This frustrating experience has ignited my interest in learning how to craft "better" code.

The good news is, there are a bunch of blog posts, forums, books, and articles about how to write better code. A few tips I've seen:

Add comments to your code; Comments that explain "why" are better than comments that explain "what"
Write tests
Name your variables clearly
The single responsibility principle: every function should do one job really well
Avoid complicated conditionals
Keep files to 250 lines of code or less

I coud go on, but there is one piece of advice that really struck me and I want to discuss it. The advice was: "Use traditional function declarations and opt for named functions over anonymous ones."

This advice caught my attention because my code is littered with anonymous functions. I can't count how many unnamed functions I've passed into .map, .forEach, and .reduce methods.

I don't think I'm alone in this. I've read time and time again that arrow functions and anonymous functions help to make code more concise and that this brevity makes for smaller files, which is part of writing better code, right? Well, it turns out that concise and anonymous does not necessarily mean better or more readable.

The more I think about this, the more it makes sense. "Well-named variables" is one of the bullet items for achieving clearer code. Variables with clear names help us to understand the data contained within them. This should also be true for functions which not only contain data, but often manipulate that data in some way too.

Let's look at a small example pulled from the Frontendmasters course, "Deep JavaScript Foundations V3" by Kyle Simpson, author of the "You don't know JS" series.

I am going to share two different implementations I wrote for a function called printRecords. One uses named functions and the other does not.

The function, printRecords should:

Accept an array of numbers (these numbers represent student Ids)
Retrieve each student record using the student Id
Sort these records alphabetically by the students' names
Print each record to the console in the following format: Name (student Id): Paid (or Not Paid)

var currentEnrollment = [410, 105, 664, 375] 
var studentRecords = [
    { id: 313, name: "Frank", paid: true, },
    { id: 410, name: "Suzy", paid: true, },
    { id: 709, name: "Brian", paid: false, },
    { id: 105, name: "Henry", paid: false, },
    { id: 502, name: "Mary", paid: true, },
    { id: 664, name: "Bob", paid: false, },
    { id: 250, name: "Peter", paid: true, },
    { id: 375, name: "Sarah", paid: true, },
    { id: 867, name: "Greg", paid: false, },
];

// Named Functions Version: 
function printRecords(recordIds){
  function findStudentRecords(recordId){
     function hasStudentId(record){
       return recordId == record.id; 
     }
     return studentRecords.find(hasStudentId);
  }
  function alphabetizeRecordsByName(a,b){
    return a.name > b.name ? 1: -1; 
  }
  function logRecord(record){
    console.log(
      `${record.name} (${record.id}): ${record.paid ? 'Paid': 'Not Paid'}`
     );
  }
  recordIds.map(findStudentRecords)
  .sort(alphabetizeRecordsByName)
  .forEach(logRecord); 
}

//Anonymous Functions Version: 

function printRecords(recordIds){
    recordIds
        .map((recordId) => 
            studentRecords.find((studentRecord) => studentRecord.id == recordId)
        )
        .sort((a,b) => a.name > b.name ? 1: -1)
        .forEach((student) => {
            console.log(
                `${student.name} (${student.id}): ${student.paid ? 'Paid': 'Not Paid'}`
            )
        })
}


printRecords(currentEnrollment); 


// Console: 
/*
 Bob (664): Not Paid
 Henry (105): Not Paid
 Sarah (375): Paid
 Suzy (410): Paid
*/

Looking at the two implementaions side-by-side in my editor, I can see that the named version of printRecords spans lines 1-23, while the anonymous version spans lines 1-12. Some of this is a result of the automated code formatter I use, but right away it's clear that the anonymous version is more concise.

Still, when I look at the named version, I understand what each function in the .map, .sort, and .forEach method is doing. I don't have to read the code line by line. It's all right there in the names: find the student records, sort them alphabetically by name, print each record. By contrast, the anonymous version requires me to look at the code in the body of each function to understand what is happening.

In this case, I would rather take the extra 11 lines of code for a better experience modifying this code down the road.

In his lecture, Kyle Simpson posits that there are at least three reasons to choose named functions over anonymous ones:

Reliable self-reference (e.g. If a function has a name, it can do things like call itself for a recursive solution)
More debuggable Stack Trace (if the function has a name, the stack trace will provide it)
More self documenting code

What do you think? Would you give up anonymous functions if it meant more human readable code? Do you use the number of lines of code as an indicator of whether a piece of code needs to be rewritten? How do ensure your code is readable 2 months down the road and beyond?

Update March 13, 2025:

I received some really great feedback on this post that I wanted to acknowledge because it encouraged me to think more (a.k.a I went down a bunch of rabbit holes) about naming conventions and not just clarity of code, but also the clarity that inherently exists (or doesn't) in human language itself.

Thank you:
@moopet
@devpacoluna
@pengeszikra
@lionelrowe
@decaf_dev
@ddfridley

The comments you left are great jump off points for me and others to continue learning and growing should they stumble across this post in the future!

** Image by Tumisu from Pixabay

JavaScript Types & Coercion Corner Cases

Bola Adebesin — Sun, 16 Feb 2025 19:33:08 +0000

Recently, I've been learning about in-depth JavaScript concepts. This has exposed me to programmer and author Kyle Simpson of the "You Don't Know JS" series.

I've heard it mentioned that JavaScript is a weird language and I've heard praise and criticism alike for it's loosely typed approach. As I've been reading parts of the EcmaScript Specification Document and learning from Kyle Simpson's videos, I have a greater appreciation for what folks mean.

Some fun examples:

-0 === 0 // true 

var workshopStudents = []; 
if(workshopStudents) // true 
if(workshopStudents == true) // false

The triple equals ignoring the negative zero was an edge case I'd never been exposed to before.

But the second example, was an even more surprising scenario. If you're familiar with the concept of falsy and truthy in JavaScript, then you know that there is a list of values that JavaScript interprets as "falsy":

undefined
null
""
0
-0
0n
NaN

Missing from that list is an empty array. So it makes sense that the conditional if(workshopStudents) evaluates to true, but is surprising that if(workshopStudents == true) evaluates to false. I learned that this happens because of how the double equals works in JavaScript under the hood.

Essentially, in the first conditional, workshopStudents is converted to a boolean type and because it is not on the falsy list it's boolean coercion evaluates to true.

In the second conditional workshopStudents, is not coerced into a boolean type first. So the two conditionals use two different evaluation algorithms. In the double equals algorithmic evaluation,workshopStudents is coerced into its primitive type before it is compared to the boolean value true. Well, it turns out the primitive value of an empty array is an empty string, "". And an empty string is on the falsy list.

Because one conditional uses the double equals and one does not they operate differently behind the scenes and trigger two different abstract operations. This leads to two outcomes that appear to contradict one another on the surface. I found this to be fascinating and kind of complex. And this is just one example of many.

I have no doubt in my mind that it's important to become familiar with these kinds of scenarios in JavaScript. I've been coding in JavaScript long enough to know when I receive an array of data from the backend I need to write if(arr.length){...} and NOT if(arr){...} if I want to avoid trying to access nonexistent data.

But I'm curious about how people typically deal with the different coercion corner cases in everyday code. After going through some exercises, I found that trying to cover all of the corner cases led to A LOT of code. I tried to make the code clear using notes referencing the corner cases, but I couldn't help but think, "This is very tedious".

One suggestion from Kyle Simpson, is to reduce polymorphic functions. So, writing a function that only accepts number and string types rather than a function that accepts numbers, string, boolean, and object types. He also recommends knowing what types you are dealing with ahead of time (e.g. before you compare two variables you should know the type of each variable and consider what corner cases may arise from the comparison).

I imagine this is also one of the reasons that TypeScript has become so popular in recent years.

"Learn Less. Understand More."

Bola Adebesin — Sun, 09 Feb 2025 15:38:55 +0000

This article landed in my inbox the other day. I was intrigued enough by the title that I seized the opportunity and re-purchased my Medium subscription.

I'm glad I did. The author articulated a sentiment I've been grappling with for some time now. Plus, he had some quotable one liners:

A generation of developers who can assemble code like IKEA furniture but can't craft it.
"Stay Relevant or Die" is a lie.
Mastery beats novelty every time.
Build libraries, not apps.
Depth defies disruption.

Maybe this is confirmation bias and this author happens to be saying what I want to hear, but his logic makes sense to me. It's the reason that, when faced with the choice between tackling Next.js, a React framework, or diving into deep JavaScript concepts, I went for the latter.

It just didn't make sense for me to try to learn one more new thing rather than striving for a deeper understanding of what I think I already know.

Don't get me wrong, I would love to become more familiar with Next.js. The idea of building even faster sites using a tool that provides more structure for React and has optimization built into it's foundation seems really, really cool. But I'm trying to accept that, as exciting as it is to pursue the shiny new things, it's the fundamentals that will get me to where I'm trying to go. Which is to technical enlightenment. Or like, becoming one with my machine or something. Unclear.

Exploring JavaScript: Higher Order Functions, Callbacks, Closures, the Event Loop and Classes

Bola Adebesin — Thu, 06 Feb 2025 18:14:06 +0000

Recently, I went through the FrontendMasters course, "JavaScript the Hard Parts" by Will Sentance. If the title of this post sounds like a lot, that’s because it is. That said, the course was clear and engaging. I would highly recommend it.

Some of what I learned is described below:

Parameters vs. Arguments:

The distinction between a parameter and an argument seems small, but I like the idea of being able to think and speak precisely. Part of that requires using words correctly even when I think they are interchangeable.

A parameter refers to the variable name that's used as a placeholder when a function is defined. An argument is the actual value that is passed to a function when that function is called.

function logString(str){
  console.log(str);
}

logString("happy");

In the above example, str is the parameter and "happy" is the argument.

Higher Order Functions vs Callbacks:

In JavaScript a higher order function is a function that accepts or returns another function. A callback is a function that is passed into another function as a parameter.

function logString(str){
  console.log(str);
}

setTimeout(logString, 1000)

In the example above, logString is the callback and setTimeout is the higher order function.

I gained a better understanding of how JavaScript executes lines of code, including creating new execution contexts when a function is called.

I reviewed concepts about the call stack and stack traces.

I learned more about closures which I thought I understood. I didn’t have an appreciation for how powerful they can be. What stuck with me was the idea that when a function is created and returned inside of another function it has access to relevant data that existed around it at the time of it's creation. Essentially, (if I anthropomorphize a closure), it has memory that it carries with it.

function outer(){
  let count  = 0 
  function incrementCounter(){
   counter++; 
  }
  return incrementCounter
}
const myNewFunction = outer(); 
myNewFunction() // counter = 1 
myNewFunction() // counter = 2

In the example above, myNewFunction can continue to act on the variable counter even though the function outer is no longer on the call stack and JavaScript has left outer's execution context by the time myNewFunction is called. Prior to this, I just thought, "a closure if a function that returns another function". Which is true, but it is so much more than that too..

The Event Loop

I didn't know that I didn't know what the event loop was. In order to understand the event loop, I had to learn about the boundary between JavaScript and the Web Browser. I learned that when I call a function like setTimeout it's actually the browser that is setting and keeping track of the timer and that as the rest of my code executes, the callback I passed to setTimeout will (at some point depending on the time I set) be placed in a task queue. The event loop will figure out when the call stack is empty and all of the synchronous global JavaScript code has completed and then move the callback from the task queue to the call stack to be executed.

And this callback will always run after the synchronous code before it, no matter how long it takes. Even with something like setTimeout(callback, 0). This is of course, assuming that there is nothing on the micro task queue as a result of calling some asynchronous code using Promises because the functions in the micro task queue receive higher priority than the functions in the task queue

Classes and the new keyword

I've used JavaScript classes before, but I liked that this course worked up to them by demonstrating different scenarios in which you might want to have your data and the functions that act on that data grouped together. Then, the different ways that objects can be created in JavaScript, and finally the syntactic sugar that classes provided to do it in a way that is readable. Although Will makes the case that this approach is deceptive in that, many people think they understand what is going on under the hood, but don't.

I learned that the new keyword used for creating an instance of an object:

Automatically creates an object assigned to this in the execution context of the “creator” function..
Links, via the hidden __proto__ property, the automatically created object to its fundamental object's [[prototype]] key, and the value assigned to that [[prototype]] key is itself an object, that holds data and methods. This gives the automatically created new object access to methods it does not have explicitly defined on itself, taking advantage of JavaScript's prototypal chain.
Returns this automatically created and linked object from the creator function.

And the class keyword gives us the chance to define this creator function (function-object) with all of the data and methods that we want it to have in one place, but doesn't really change anything under the hood. It does look nice though.

The End
All of this made me feel like I have a better understanding of JavaScript than I did before. I believe my mental model of the language is a little clearer. I am left with some questions though:

How can I apply this new understanding to write better code?
What ways can I use this information in the wild?
I've seen people say that it is important to understand JavaScript classes, but not to use them. Why? What are the trade offs?

Collections in Java

Bola Adebesin — Sun, 18 Jul 2021 12:21:37 +0000

Collections

In Java, a collection is a class whose main purpose is to store a collection(or group) of other elements. This could be a group of integers, strings, boolean values, objects, etc.

Collections are divided into 3 major groups: Set, List, and Map.

Set

An unordered group of elements, each. element in a collection is unique:

import java.util.HashSet;

public class Solution {
    public static void main(String[] args) throws Exception {
        HashSet<String> set = new HashSet<String>(); 
        set.add("watermelon"); 
        set.add("banana"); 
        set.add("cherry"); 
        set.add("pear"); 
        set.add("cantaloupe"); 
        set.add("blackberry"); 
        set.add("ginseng"); 
        set.add("strawberry"); 
        set.add("iris"); 
        set.add("potato"); 

        for(String word: set){
            System.out.println(word); 
        }

    }
}

Despite the order of the strings added being:

watermelon
banana
cherry
pear
cantaloupe
blackberry
ginseng
strawberry
iris
potato

When the System.out.println method is called on each element in the set (using a for each shorthand), this is the order that the words are printed:

banana
cherry
pear
iris
blackberry
ginseng
potato
strawberry
watermelon
cantaloupe

The order is different.

Lists

In a list, each element is organized by an index. (A familiar example of a list is an array). Because each element is associated with a number, it is an ordered collection and one can access a specific element if one knows the correct index. It's kind of like looking for your friend when you have their address, it is much easier to locate them when you have this information that identifies their location.

import java.util.List;
import java.util.ArrayList; 

public class Solution {
    public static void main(String[] args) throws Exception {
    ArrayList<String> list = new ArrayList<String>(); 
        list.add("Hello World"); 
        list.add("Goodbye Mars"); 
        list.add("Salutations Venus"); 


        for(String word: list){
            System.out.println(list.indexOf(word) + ":" + word); 
        }

    }
}

The result of the above code is:

0:Hello World
1:Goodbye Mars
2:Salutations Venus

Maps

Maps are a group of key-value pairs. Unlike lists, in which each element is identified by an integer beginning from zero, maps can be identified by name. In maps, each key must be unique, but the values do not have to be unique.

import java.util.HashMap;
import java.util.Map;

public class Solution {
    public static void main(String[] args) throws Exception {
        HashMap<String, String> map = new HashMap<String, String>(); 
        map.put("K-Drama", "This is my first life"); 
        map.put("Drama", "Start Up"); 
        map.put("Anime", "One Piece"); 
        map.put("Comedy", "Grownish"); 
        map.put("Animation", "Bob's Burgers");
        map.put("Romance", "Pride and Prejudice"); 


        for(Map.Entry<String, String> pair: map.entrySet()){
            String key = pair.getKey(); 
            String value = pair.getValue(); 

            System.out.println(key + " : " + value); 
        }

    }
}

The output of the above code is:

Anime : One Piece
Drama : Start Up
K-Drama : This is my first life
Animation : Bob's Burgers
Romance : Pride and Prejudice
Comedy : Grownish

Bonus:

In the three examples above, the following syntax is used:

for(String text: set){
  System.out.println(text); 
}

This is Java shorthand for iterating through collections. It allows us to iterate through these groups of elements by using an implicit iterator. The longer version of this looks like"

Iterator<String> iterator = set.iterator(); 
while(iterator.hasNext()) // Check if there is another element 
{
   //Get the current element and move to the next line 
    String text = iterator.next(); 
    System.out.println(text); 
}

Static Variables and Methods (Java)

Bola Adebesin — Fri, 02 Jul 2021 21:00:40 +0000

Variables

Static variables are tied to the Class itself. Each object of a class shares the static variable.

Non-static variable (instance variables) are tied to the object. In the example below, every object of the Cat class has its own name variable. However, every object shares the catCount variable.

When you see the static keyword in front of a variable name think of a shared variable.

Class Cat 
{
String name; // Non-static variable (each object has it's own copy) 
static int catCount; //Static variable (each object of the class Cat shares this variable

Cat(String name){
this.name = name; // Non-static variables can be referenced with "this" keyword 
Cat.catCount++; // Static variables are referenced using the class name 
}

Methods

Java methods are divided into two categories. Instance methods and Static methods.

Instance Methods

These methods are called on an object and they have access to an objects data (non-static variables). This makes sense. Since an object is an instance of a class, an instance method works on objects.

The reason that instance methods are able to access an objects data is because they have a reference to the object. That reference is stored in the keyword "this". "this" holds a reference that tells us where the object we are referencing is. Without "this" we can't refer to the object.

When you call an instance method, the object that you called the method on is actually passed along to that method as the first argument, we just don't see it.
What we see:

Cat sally = new Cat(); 
String name = sally.getName();

What is actually happening:

Cat sally = new Cat(); 
String name = Cat.getName(sally);

The object sally is being passed into the getName method. Then inside the method, the object sally will be referred to as "this".

Static Methods

These methods do not have access to an objects data. Since they don't have an object reference. Static methods don't have "this". Instead a null value is passed to static methods. But, static methods can reference the static variables of the class and other static methods.

Static methods allow us to call a method before we create any objects because they are tied to the class not the object. This is how the main() method works for example.

Views in SQL

Bola Adebesin — Wed, 30 Jun 2021 00:12:57 +0000

What is a View

TLDR: A view is like a query you can save for later.

A view is defined as a mechanism for querying data. I think of it as a way to create a query and save it for later. By creating a view you have access to a specific set of data without creating a new table or taking up space.

How Can I create a View

A view can be created by assigning a name to a select statement and then storing the query for others to use. (Similar to how we can store a value in a variable to use later). Then, other people can use your view to access data as if they were querying an actual table. Sometimes you don't even know you're using a view.

CREATE VIEW customer_vw 
AS 
SELECT 
customer_id, 
first_name name,
last_name surname, 
concat(substr(email, 1, 2), '*****', substr(email, -4)) email 
FROM customer;

The first part of the statement gives the view a name customer_vw. The second part of the statement is a select statement which must contain one expression for each column in the view.
Once this view is created it can be queried just like a table!

We can also use desc customer_vw to examine the fields and types that make up the data in the view.

You can join views to other tables too.

Why Use Views

Data Security - you can use views to mask data you don't want others to see
Data aggregation - you can use views to preaggregate data so that when others query the view they are querying data that may be more meaningful than just raw data from the database.
Hiding Complexity

Constructors in Java

Bola Adebesin — Tue, 29 Jun 2021 02:31:12 +0000

Recently, I've been learning Java. The goal of this article and subsequent writings is to write a short blurb about the topics, I cover each day to help reinforce my learning and hold myself accountable.

Constructors are special methods (functions associated with classes) that create a kind of skeleton that each new object (instance of a class) must match.

I like to think of constructors like a checkpoint when you make a new object. Your object cannot move passed the checkpoint (i.e. your program will throw an error) if the criteria specified by the constructor are not met. And by setting these criteria, we ensure that our objects always have a valid state. When we use constructors all of our variables are initialized.

Example without Constructor:

class Main {
  public static class Car{
    String model; 
    int maxSpeed;

  }


  public static void main(String[] args) {

    Car newCar = new Car(); 
    newCar.model = "Toyota"; 
    newCar.maxSpeed = 100; 

    System.out.println(newCar.model); 
    System.out.println(newCar.maxSpeed);
    }
  }

Output:

Without a constructor, I can create a car object newCar without initializing any variables. Instead, I initialize the model and maxSpeed variables on the following lines. Not only does this take up more space. But if I forget to do this step, my program will have errors later on in life.

In the example below, we create a constructor by using the keyword public create the method Car (the same name as our class, this is important), and then pass the variables we want to initialize when our object is created (in this case the model and the maximum speed of the car). By using the this keyword we are referencing the specific object we are creating. so this references this Car not some other car.

Example with Constructor:

class Main {
  public static class Car{
    String model; 
    int maxSpeed;

    public Car(String model, int maxSpeed){
      this.model = model; 
      this.maxSpeed = maxSpeed; 
    }

  }
  public static void main(String[] args) {

    Car newCar = new Car(); 
    newCar.model = "Toyota"; 
    newCar.maxSpeed = 100; 

    System.out.println(newCar.model); 
    System.out.println(newCar.maxSpeed);


    }
  }

The image below shows that when I include the constructor on lines (6-9) I can no longer create the `newCar` object without initializing the variable. The editor underlines the object to indicate an error.

If the code is run the following error is produced:

But when we correctly pass the expected arguments to our constructor:

class Main {
  public static class Car{
    String model; 
    int maxSpeed;

    public Car(String model, int maxSpeed){
      this.model = model; 
      this.maxSpeed = maxSpeed; 
    }

  }


  public static void main(String[] args) {

    Car newCar = new Car("Toyota", 100); 
    // newCar.model = "Toyota"; 
    // newCar.maxSpeed = 100; 

    System.out.println(newCar.model); 
    System.out.println(newCar.maxSpeed);


    }
  }

We get the following output:

So again, constructors help us ensure that our objects are valid and have everything they need. A great way to dummy proof our code.

Recursion

Bola Adebesin — Mon, 15 Feb 2021 17:16:49 +0000

Recursion

Intro

Recursion can be an intimidating topic. (There's a reason I chose a seemingly endless and slightly sinister-looking spiral staircase for the cover photo of this article). Until a couple of days ago, when asked about recursion, the only real answer I could muster was, "It's a function that calls itself". Which is a true answer, if not a complete one.

As with most challenging or tricky topics, when we break it down into smaller chunks, give ourselves time to digest, and practice, we can get it. So let's try to do some of that now.

Pre-requisites

Some concepts that are important to understand in order to cover this topic are:

Familiarity with JavaScript as this is the language used for the code examples
Loops: for loops, while loops, etc.
A basic understanding of how functions and function calls work (e.g. functions run in a particular order, functions can contain other functions, functions can call other functions.

Note: I have a tendency, for better or worse, to anthropomorphize concepts. I like to think this provides a friendly and low-pressure atmosphere.

Functions Calling Functions

One great thing about functions is that, in most cases, they are orderly and polite. What I mean by that is, they tend to run in a predictable order. We can usually predict the order in which functions will execute. So when we call one function inside another, the outer function will wait for the inner function to complete before completing itself. Let's look at an example of this:

function makeFlashcards(){
    let languages = ["Python", "Java", "JavaScript"];
    languages.forEach((language) => {
        console.log(`Make a ${language} flashcard`);
    })
    return 
}

function watchUdemyVideo(){
    console.log("Watching Udemy Video"); 
    makeFlashcards();
    return 
}

function study(){
    watchUdemyVideo(); 
    console.log("All done studying!")
    return 
}

study()

Bonus: Before moving on to the section below, try and see if you can figure out the order the phrases above will print based on the order of the function calls.

Let's walk through what's happening here.

After we define our three functions (makeFlashcards, watchUdemyVideo, study) we call the study function.
Immediately study calls watchUdemyVideo. Now, study is waiting. It does not move on to the next line yet.
watchUdemyVideo prints "Watch Udemy Video". Then calls makeFlashcards. Now watchUdemyVideo is waiting AND study is still waiting too.
makeFlashcards cycles through the array, languages, and prints a phrase for each flashcard. Then it returns.
Now that makeFlashcards has returned, watchUdemyVideo can stop waiting and return.
After watchUdemyVideo returns, study can stop waiting. It prints "All done studying" and finally returns too.

So in the console, we should see:

Watching Udemy Video
Make a Python flashcard
Make a Java flashcard
Make a JavaScript flashcard
All done studying!

So, now we've demonstrated how functions can call other functions and that each function will wait until the function inside of it is completed.

Recursion is really a continuation of this same idea except, instead of function a calling function b and waiting for function b to return, function a calls itself and waits.

The Call Stack

What we've described, the waiting functions, actually has terminology that we can use to be more precise, the call stack.

The call stack is responsible for managing the order in which functions are executed. When a function is called it is placed on the call stack. When a function returns (finishes executing) it is removed from the call stack. So in the example above, the functions would be added to the call stack as follows:

study is added
watchUdemyVideo is added on top of study
makeFlashcards is added on top of watchUdemyVideo

The functions would be removed from the stack in the following order:

makeFlashcards returns and is removed.
watchUdemyVideo returns and is removed.
study returns and is removed.

Another way to describe this behavior is "last in first out". If this seems confusing or unintuitive, just think, there are real examples of this every day.

Imagine you are making pancakes. You make the first pancake and you add it to the plate. Then you make the second pancake and add it to the plate. You add the second pancake on top of the first and so on. Eventually, you have this stack (ha!) of pancakes. When you're ready to consume your pancakes what do you do? You eat the pancake on top. So the last pancake you made is placed on top of the stack and is the first one you eat. Last in, first out.

Ok, so now that we have a better understanding of functions calling other functions and the call stack let's get to recursion.

Recursion

Earlier, I mentioned that recursion is a function calling itself. Until a few days ago, that was the only way I thought of it. Really, recursion is a tool in our developer toolbox that provides a different way of solving problems.

Let's look at an example below. We can solve the same problem recursively(using recursion) or iteratively (without recursion).

Problem: Write a function that takes a positive integer and returns the product of all the integers from 1 to that integer a.k.a. find the factorial. For example: if the input is 3, the output should be 6 (the product of 3 * 2 * 1)

Given the same inputs, these two functions return the same outputs. (Feel free to try it out here on CodePen.)

Although this is a simple example, with our recursive solution, we didn't have to initiate separate variables product and i or loop through a for loop. Instead, we used the given parameter, a conditional, and a function call.

These are the fundamental components in a recursive solution. Let's take a closer look at them.

3 Parts of the Recursive Function

The Base Case / Conditional
The Recursive Call
The Modified Input

We can gain an understanding of how these components work by examining what happens if we remove them or leave them out:

Without the base case, the recursive function would theoretically run forever (actually the call stack has a limited amount of space so eventually we would see the stack overflow error). Additionally, if we include a base case that doesn't match the changes we make to the input, we end up with the same issue. In the example above, if we kept our base case, but added 1 to num instead of subtracting 1 from num, we would never reach a point where num === 1. It's also important that we have a return statement. If we replaced the return statement with a console.log(1) instead, our recursive function would continue to run. Remember, it the function hitting a return that causes it to finish executing and to be removed from the call stack.
Without the recursive call, none of this works. This may seem obvious, but the function must call itself if the base case has not been met.
Without modifying the input, specifically in a way that moves it towards the base case, the recursive call will never stop. Again, in our example above, if we continued passing num, unmodified, into our factorial function, we would never reach our base case.

Let's step through what's happening. We want to know if the base case has been met and if it has return 1. If not, we want to make another recursive call with a modified input.

When 3 is passed in, we have not met our base case so we return 3 * factorial(3-1). Now factorial(3) is on the call stack, waiting on the return value of factorial(2). (Number 1 on the diagram)

Now 2 is our input. It does not meet our base case. So we return 2 * factorial(2-1). Now factorial(3) and factorial(2) are both on the call stack waiting. (Number 2 on the diagram)

Now our input is 1. It does meet our base case. So factorial(1) returns 1! (Numbers 3 and 4 on the diagram). If we didn't have a base case and return a value, the diagram would go on forever.

Now we can work backwards. factorial(2) can return with 2 multiplied by the value returned from factorial(1) (in this case 1). So 2 * 1 = 2. Now factorial(3) can return. It returns 3 multiplied by the value returned from factorial(2) (which is 2). This leads to 3 * 2 = 6.

All our functions have returned, our stack is empty, and we've got our answer: 6.

Why Does Recursion Matter?

Although the example above was simple, there are times when recursion offers a cleaner solution than an iterative one.

Recursive functions are a great way to learn to step through functions and understand the order that they are called and executed.

It's great for problems that can be broken down into small repetitive tasks.

I Still Don't Get It

If you still don't get it that's ok. Sometimes you have to sit with a concept or idea before it really clicks. Practicing helps. Start simple and work up to more challenging examples. Google Chrome is a great tool because it allows you to step through recursive functions(all functions really) and see what is on the call stack and what is being returned from each function on the stack at each step. Most importantly, don't give up.

Resources:

Tools to practice:

CodePen
Chrome Browser

Other Learning Resources:

If you learn better from videos Colt Steele has a great video on recursion.
GeeksForGeeks has an article on recursion.

Introduction to HTTP

Bola Adebesin — Mon, 01 Feb 2021 22:37:54 +0000

What does HTTP stand for?

HTTP stands for HyperText Transfer Protocol. If the acronym is intimidating, don't worry we'll break these four words down further.

Even if you're brand new to web development, you've likely heard of HTML, which stands for HyperText Markup Language. Any of that acronym seem familiar? (Hint: it's the "hypertext" part).

HTML is a text-based approach to describing the structure of a web page's content. It is the major markup language used across the worldwide web. (W3 Schools)

Okay, so HTML gives us the structure, or essentially, tells us how content on a web page should be organized. HTTP provides the rules (protocol) for how that content should be sent and received or transferred across the web. It is the foundation of any data exchange on the web. Hence, HyperText Transfer Protocol.

To give you an analogy, let's say you want to order a bookcase from a furniture company. You have to provide that company with information about what type of bookcase you want, maybe the size, color, and model. The company has to process this information and get the bookcase to your door somehow. The rules, or protocol, the company uses to get the bookcase to you is HTTP. Once your bookcase arrives, the instructions for how to build the bookcase, how the pieces should be organized, is HTML. (Note: this simple analogy is imperfect but hopefully useful).

How does HTTP work?

Now that we have a better understanding of what HTTP is, let's talk about how it works.

Commonly, HTTP is defined as a stateless, "client-server" protocol or "request-response" protocol. The client-server protocol describes the communication between two computers. The client (maybe a browser or another application) requests data and the server provides a response. This is how we are able to go to a website (make a request) and see information (get the response). With this protocol, the client request always happens first and is followed by the server's response.¹

"Stateless" describes the fact that once the server provides a response, it isn't required to keep information stored about each user. Each request is executed without any knowledge of the requests that were executed before it or after it.¹

HTTP Request

The request is where it all begins. Let's look at the components of a request¹:

Request line
Request Headers (it is possible to have zero headers)
An empty line
The message body (optional)

GET /Protocols/rfc2626/rfc2616.htmll HTTP/1.1
Host: www.w3.org
User-Agent: Mozzila/5.0
(empty line)

The first word in the first line (GET) is the request method. This is the action that we want to be done. In this case, we literally want to get some information. GET was the first method and is the most fundamental it is supported with all browsers because it is how we get content.

For your reference, a list of methods taken from TutorialsPoint

Methods	Description
GET	The GET method is used to retrieve information from the given server using a given URI. Requests using GET should only retrieve data and should have no other effect on the data.
HEAD	Same as GET, but transfers the status line and header section only.
POST	A POST request is used to send data to the server, for example, customer information, file upload, etc. using HTML forms.
PUT	Replaces all current representations of the target resource with the uploaded content.
DELETE	Removes all current representations of the target resource given by a URI.
CONNECT	Establishes a tunnel to the server identified by a given URI
OPTIONS	Describes the communication options for the target resource.
TRACE	Performs a message loop-back test along the path to the target resource.

The request method is followed by the URI (Uniform Resource Identifier - we'll discuss this later) and the version of HTTP being used (yes, there is more than one version). While the request method holds the desired action, the headers contain other information for the server. Most of them are optional, but the host header field (which provides the name of the server along with the port number) is required.¹

HTTP Response

We discussed how it all begins with a request. Well, every time there is a request an HTTP response is sent. Fortunately for us, the components that make up the HTTP response are very similar to the components that make up the HTTP request¹:

Status line
Response headers (can be zero)
An empty line
The message body (optional)

HTTP/1.1 200 OK
Date: Mon, 27 Jul 2009 12:28:53 GMT
Server: Apache/2.2.14 (Win32)
Last-Modified: Wed, 22 Jul 2009 19:15:56 GMT
Content-Length: 88
Content-Type: text/html

The first line is the status line. It has a status code that provides information on whether or not the success was successfully processed. Followed by response headers. This provides more information to the client the same way request headers provide more information to the server. Another lovely table also take from TutorialsPoint

Status Codes:
Status Code Class|Description
-----------------|--------------
1xx|Informational. It means the request was received and the process is continuing.
2xx|Success.| It means the action was successfully received, understood, and accepted.
3xx|Redirection. It means further action must be taken in order to complete the request.
4xx| Client Error. It means the request contains incorrect syntax or cannot be fulfilled.
5xx|It means the server failed to fulfill an apparently valid request.

URI

Previously, I mentioned the URI (Uniform Resource Identifier). You may be more familiar with the term URL (uniform resource locator). The relationship between URIs and URLs is kind of like the relationship between rectangles and squares. All squares are rectangles, but not all rectangles are squares (Wow, what a throwback to my grade school lessons on shapes). All URLs are URIs but not all URIs are URLs. URIs allow us to identify distinct resources. We can do that with a URL (which tells us exactly where to find a resource ), but we can do that with other things too. Like a URN (uniform resource name), which tells us what a resource is called, but not how to find it.

If this is interesting (or confusing to you. Wikipedia has a great article breaking down the history and usage of all three), but I pretty much use URL and URI interchangeably.

The goal of this article is to walk through HTTP since it's an integral part of web applications that is important to understand. When I was first learning about web development it felt like a topic that was important, but my understanding was kind of fuzzy. Hopefully, this article can provide some clarity.

[1]: Sau Sheong Chang. Go Web Programming

Preparing for the AWS Certified Cloud Practitioner Exam

Bola Adebesin — Tue, 01 Dec 2020 02:33:40 +0000

Background

The goal of writing this article is twofold. One, because I have just completed the Cloud Practitioner Certification, I want to share how I prepared for the exam while everything is still fresh in my mind. Two, if this post can be a helpful resource or serve as encouragement for anyone else considering getting the certification, that would be great! So without further ado, let's get to it!

What is the Certified Cloud Practitioner Exam?

The Amazon Web Services (AWS) Certified Cloud Practioner exam is the first level of AWS certifications i.e. a foundational certification. It is a great starting point for individuals to gain "an overall understanding of the AWS cloud".

Why should you pursue this certification?

As stated above, this certification is a great introduction to "The Cloud". More and more companies are moving to take advantage of the cost benefits, reduced hardware maintenance, and global infrastructure of cloud-based services.

Fast Facts about the Exam

While the Official AWS Exam Guide details:

What you need to know (broken down under different domains)
Links to official training courses and materials
Response Types
How the exam is scored

I was interested in the following:

65 Questions
100 minutes
Price of the exam is $100 USD
Two styles of questions: multiple choice (one correct answer) AND multiple responses (two correct answers out of five)
Exam is scored from 100 to 1000 and you need at least a 700 to pass
Unanswered questions are scored as incorrect and there is no penalty for guessing
You can take the exam at home or at a testing center

How I Prepared

My background: I have about one year of experience working as a full-time developer. My company does use AWS, but my personal experience with AWS Services was pretty limited. I had worked with EC2 instances, S3 buckets, and some of the IaaS (infrastructure as a service) tools, but would still label myself a beginner.

Time to Study: I spent approximately a week and a half preparing for the exam. I saw individuals recommend anywhere from 10 to 20 hours of study time depending on one's familiarity with AWS.

Resources (aka The Good Stuff):

Blogs:
- This post by Kedar Dabhadkar
- This post by Jeanne Boyarsky
These blog posts were well-organized and extremely helpful in my preparation.
Videos:
- Firsthand exam experience from Steep Technologies. I just found it nice to hear someone else's experience.
- Topics to Study By Peter Fessel. I will say this, every topic he mentions was on my exam, but there were a few topics on my exam that he did not mention.
- (Almost) Everything You Need to Know from Andrew Brown. Honestly, shout out to Mr. Brown. This video got me 70% of the way there. After watching it, I didn't feel like I needed to watch anything else. I just made flashcards and did practice exams. I also didn't need to read all the white papers although I did skim some of them for more information on concepts I was struggling with such as the 5 Pillars of the AWS Well-Architected Framework
Practice, Practice, Practice:
Once, I felt like I had a good foundation my approach was to drill and then test. For me, that meant making flashcards and then doing practice exams.

Flashcards

For my flashcards, I used a program called Anki, which automates spaced-repetition, allows you to sort cards based on how well you feel you know the material, and a has bunch of other pretty cool features. I also really like Quizlet. If you go the flashcard route, I would suggest making the cards yourself as I believe that making the cards helps with retaining the info.

Practice Exams

For practice exams, I completed the first four exams from Udemy (I found many people who stated that the last two practice exams were out of scope for this test), 20 free questions from Whizlabs and the four practice exams also from Whizlabs, and 10 free questions from AWS.

The Udemy practice exams were structurally more similar to the test than the WhizLab questions because Whizlab had questions where three out of five answers might be correct, but the exam only ever asked for two correct answers at most. I still really liked Whizlabs because each explanation linked directly to resources on the AWS site with more information. I also think the level of difficulty of the Whizlabs questions was great too. On the exam, there were questions that were close enough to the practice exams that I might not have gotten correct otherwise.

How Much Did It Cost?

In total, I spent $117.94:

$100 for the exam
$7.95 for the WhizLab Practice Exams (on sale at the time)
$9.99 for the Udemy Practice Exams (on sale at the time)

Some people recommended the ACloudGuru course, but at the time I looked the subscription was for $299/year or $49/month. I've heard really good things about this platform for the associate level courses and beyond, but I felt confident that I could spend less and still do well on the exam so I opted not to enroll.

The End

Whew! Okay, we made it to the end. Thanks for sticking with me. I hope that you found this article helpful and best of luck on your certification exam and more importantly, your AWS Cloud journey!

DEV Community: Bola Adebesin

JavaScript: Linked Objects

Writing Human Readable Code: To Name or Not To Name

JavaScript Types & Coercion Corner Cases

"Learn Less. Understand More."

Exploring JavaScript: Higher Order Functions, Callbacks, Closures, the Event Loop and Classes

Collections in Java

Collections

Set

Lists

Maps

Bonus:

Static Variables and Methods (Java)

Variables

Methods

Instance Methods

Static Methods

Views in SQL

What is a View

How Can I create a View

Why Use Views

Constructors in Java

Output:

Recursion

Recursion

Intro

Pre-requisites

Functions Calling Functions

The Call Stack

Recursion

3 Parts of the Recursive Function

Why Does Recursion Matter?

I Still Don't Get It

Introduction to HTTP

What does HTTP stand for?

How does HTTP work?

HTTP Request

HTTP Response

URI

Preparing for the AWS Certified Cloud Practitioner Exam

Background

What is the Certified Cloud Practitioner Exam?

Why should you pursue this certification?

Fast Facts about the Exam

I was interested in the following:

How I Prepared

Flashcards

Practice Exams

How Much Did It Cost?

The End