DEV Community: Taslan Graham

Scaffold Node.js APIs quickly with Todo-CLI

Taslan Graham — Wed, 15 Dec 2021 12:21:57 +0000

Hey, y’all! Hope you're doing great! It's been a while since I’ve posted an article. During this period I spent some time working on a node.js CLI for scaffolding APIs. In this article, I want to introduce you to the tool I created, Tode-CLI.

Why I created the tool?

First, I want to give a little insight into why I created the CLI I'm about to tell you about. I love using node.js (with express.js) to create APIs. It’s fast and simple to use.

However, I dislike having to create common things like models, controllers(routes), and service files from scratch each time I needed one. Additionally, I dislike the tedious efforts needed to set up authentication in applications that requires some level of authentication/authorization.

This led me to ask the question, “what can I do to avoid this repetition?”. So, I decided to build a simple tool that could automate some of these things for myself.

After working on the tool, I decided to publish it to npm in case someone else might find it useful. Let’s take a closer look at the tool I created.

Introducing Tode-CLI

Tode-CLI is a tool for scaffolding node.js APIs. It provides commands to automate the boring stuff – creating models, services, controllers, registering routes. Thus, speeding up your development time.

Tode-CLI comes with an elegant ORM, objection.js, built on top of the famous query builder, knex.js. This makes interacting with databases a breeze when working with projects created by tode-cli.

The following will explore some features of the CLI.

Features

In this section, I'll take a quick look at some of the core features of the CLI and give usage examples.

Generate/scaffold a project

The tode-cli provides a command to scaffold a project that has a straightforward folder structure. You scaffold a project by running $ npx tode-cli create-project hello-world.

This will generate a project, called hello-world, with the following folder structure:

Run npm i to install the node packages, then run npm run dev to serve your app locally. Your app will be served at http://localhost:8080/.

Hitting http://localhost:8080/ via a client (web browser, postman, etc) will give the following response:

The response above is showing all the none nested routes within the application. By default, a example route comes with the application.

Adding a Controller

In node applications, it is common to use route files to handle the routing in the app.
However, in a tode-cli generated application we call these files controllers and they are stored in the controllers folder. Future updates may see a complete separation of controllers from routes, similar to what popular tools like Laravel and adonis.js does.

To add a controller to your app you simply run $ npx tode-cli add:controller <controller_name>. This will scaffold a controller(route) file like the following:

import { Request, Response, Router } from "express";

module.exports = () => {
  const router = Router();
  /**
   * Create a new Item
   */
  router.post("/", async (req, res) => {
    return res.send('demo/ - POST');
  });

  /**
   * Get all Items
   */
  router.get("/", (req: Request, res: Response) => {
    res.send("demo/  - GET");
  });

  /**
   * Get an Item by Id
   */
  router.get("/:id", (req: Request, res: Response) => {
    res.send("demo/  - GET /id");

  });

  /**
   * Update an Item
   */
  router.patch("/:id", (req: Request, res: Response) => {
    res.send("demo/  - PATCH /id");

  });

  return router;
};

Here we created a controller named demo. This controller is created with handlers for some basic HTTP request methods such as GET, POST, PATCH on the '/demo' path.

We can test that our controller is working by hitting http://localhost:8080/demo via a client(web browser, postman, etc). We should get the following response:

If we hit http://localhost:8080 again we will see the demo route in our list of routes. As you can see here, tode-cli apps offer a level of self-documentation for the routes within the application.

Models

Models are classes that represent a table in your database. You use methods on the model to perform queries on the table it represents via an easy-to-use ORM, Objection.js.

To create a model you run the command $ npx tode-cli add:model <model_name>. You'll get a generated model like the following:

import BaseModel from "../BaseMode";

export class User  extends BaseModel {
  // Name of table that this model maps back to
  // Table name is the only required property.
  public static tableName = 'ENTER_TABLE_NAME';
  // Example property
  public foo!: string;

  // Add other table fields (columns) as properties to access them via the model

  // Define the relations to other models.
  // READ MORE at https://vincit.github.io/objection.js/guide/relations.html
  public static relationMappings = () => ({
    // specify relation with other modules
  })

}

In the above, I generated a model called User. Models on have one required property, tableName, which holds the name of the database table that the model represents. You can perform a query to fetch all users in your database table using await User.query(). Read more about objection.js' queries here.

The static method relationMappings is where you define your model's relationship with other models - basically representing your database relationships. Read more about objection.js' relationships here.

Note: To use your models to perform queries you'll first need to set up a database connection to the database with your tables. Read more here.

Services

Service files contain your business logic. To create a service you run the command $ npx tode add:service <service_name>. When you create a service, a file will be generated like the following.

import { ServiceReponse } from "../../config/constants";

class UserService {
  private _foo = "foo";

  constructor() {
    //
  }

  get foo() {
    return this._foo;
  }

  set foo(val: string) {
    this._foo = val;
  }

  public foobar() {
    //
  }
}

const UserService = new UserService();

export { UserService };

The above is the generated file for a service called UserService. You can then add methods to perform any logic inside this file. You'll then call these methods from within a controller or another service. Services are also where you utilize your Models to perform database queries where necessary.

Authentication

Authentication is an essential part of most applications these days. With Tode-Cli you can integrate basic JSON Web Token (JWT) based authentication in your application by running a single command, $ npx tode-cli add:auth.

This command will create the following:

Knex Migration to create a Users table in your database
Login functionality which you can customise
Registration functionality which you can customize
Auth middleware which you can use on protected routes
Login route - /auth/login
Registration route - /auth/register

All you'll need to do afterward is create the users table in your database by executing the migration file that was created. To do this, run the command $ npx knex migrate:latest. Now authentication is fully integrated.

Technologes used

Tode-CLI was developed with the following:

TypeScript
OCLIF - an open source framework for building command line interfaces (CLI) in Node.js.

We've covered some of the core features of Tode-CLI. I first created this tool for my personal use. I hope someone else finds it useful.

You can have a deeper dive into the docs and configurations here. Feel free to try it out. Don't hesitate to report any issues you come across. I aim to improve the CLI as time goes by.

Thanks for reading, and until next time! Think, Learn, Create, Repeat!

I've reached 20,000 views

Taslan Graham — Sun, 08 Aug 2021 15:51:13 +0000

I recently reached 20k reads on dev.to.

Thank you to everyone who has taken the time out to read my articles!

Glad I'm able to provide value to the community.

Node.js Event Emitter

Taslan Graham — Thu, 05 Aug 2021 08:33:12 +0000

Node's event-driven architecture allows us to execute certain actions when something happens. This is done via objects (called "emitters") which can emit named events that cause functions ("listeners") to be executed. Objects that emit events are instances of node's EventEmitter class, made available via the events module. In this article we'll look at node's event emitter.

Creating an Emitter

Let's create an event to explore some of basic concepts with node's EventEmitter

// Require in the events module 
const EventEmitter = require('events');
const carEvent = new EventEmitter();

The events module provides us with the EventEmitter class. We then create an instance of EventEmitter called carEvent. Now let's explore some of the methods available to us.

Adding a listener

As mentioned earlier listeners are callbacks that gets executed when we emit a named event. Here's how you'd create an event listener on our carEvent emmiter.

carEvent.on('start', function(){
  console.log('Started the car.');
});

Here we are registering a listener for the event named start. This will be executed when we emit an event of said name.

We can also add multiple listeners to a single event. Let's add another:

carEvent.on('start', function(){
  console.log('Car started. Ready to go!');
});

Next we'll emit events to trigger these listeners.

Emitting an Event

All listeners for an event will be called synchronously in the order in which they were registered.

We trigger the listener(s) for an event by calling the emit() method with the name of the event as the first argument. Any subsequent arguments will be passed on as arguments to the listeners.

carEvent.emit('start', 'Hello! ');
// Started the car.
// Car started. Ready to go!

Above we emitted the start event which resulted in all listeners attached to the start event being executed. Now lets update our second listener to make it accept an argument.

carEvent.on('start', function(greeting){
  console.log(greeting, 'Car started. Ready to go!');
});

Now we emit the start event and get the following:

carEvent.emit('start', 'Hello!');
// Started the car.
// Hello! Car started. Ready to go!

Removing a listener from an event

The removeListener() method removes a listener from an event. This takes the name of the event, and the handler function to be removed as arguments. Calls to this method only removes a single instance of a listener, so if you have a listener that was added multiple times then you'd have to call the removeListener() method multiple times to remove each listener.

function a(){
  console.log('Called listener function');
}

// Add listener to event
carEvent.on('A', a);

// Emit event
carEvent.emit('A');
// Called listener function

// Remove listener
carEvent.removeListener('A', a);

// Emit event again
// Nothing happens, event was removed
carEvent.emit('A');

The removeListener method emits an event, removeListener, after the listener has being removed.

More methods

The on() and emit() methods are the most commons ones used when when working with event emitters in node. However, lets take a look at some other useful methods available to us.

Once

The once() method adds a listener that will be executed only, you guessed it :) , once.

// Adds a listener to be executed once
carEvent.once('stop', function(message){
  console.log(message);
});

Now when emit the stop event, node will remove the listener(from list of listeners attached to the event) then invoke it.

// Executes the first time we emit the stop event
carEvent.emit('stop', 'Stopping....');
// Stopping....

// Emit the stop event a second time
// Nothing happens
carEvent.emit('stop', 'Stopping....');

setMaxListeners

The setMaxListeners() method allows you to set to the maximum number of listeners that can be attached to a single event. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

// Sets a maximum of two listeners for any event on the carEvent emitter
carEvent.setMaxListeners(2);

If we add more than two listeners to any event then we'll get a warning like the following:

// Add thre listeners to a single event
carEvent.on('eventA', function(greeting){});
carEvent.on('eventA', function(greeting){});
carEvent.on('eventA', function(greeting){});

(node:17787) Warning: Possible EventEmitter memory leak detected. 3 eventA listeners added. Use emitter.setMaxListeners() to increase limit

listeners

The listeners() method returns an array of the listeners registered for an event.

const listeners = carEvent.listeners('start');
console.log(listeners);
// [ [Function], [Function] ]

eventNames

Returns an array listing the name of events for which the emitter has registered listeners.

console.log(carEvent.eventNames());
// [ 'start', 'stop', 'eventA' ]

Extending The EventEmitter Class

We can create our own objects that has its own set of properties and methods along with the ones provided by node's EventEmitter.

const EventEmitter = require('events');

class Car extends EventEmitter{
  constructor(brand, year){
    super();
    this.brand = brand;
    this.year = year;
  }

  turnRadioOn(){
    console.log('radio turned on');
  }
}

Above we created a class that inherits from the EventEmitter class as well as having two properties(brand, and year) of its own along with a method, turnRadioOn.

Now instances of the Car class will have access to both the properties and methods on the Car class as well as all the ones inherited from the EventEmitter class.

const car = new Car('BMW', '2021');

// Adds a listener
car.on('start', function(){ console.log(this.brand + ' started') });

// Emit the event
car.emit('start');
// BMW started

// Call method defined on Car class
car.turnRadioOn();
// radio turned on

Conclusion

Node's EventEmitter allows us to create objects with listeners that gets executed when we emit an event that the listener is registered to.
We covered methods including the on(), emit(), removeListener() methods. We also looked at how we can extend the EventEmitterwhen creating our own classes.

Did you find this useful? Let me know if the comments. Until next time, think, learn, create, repeat!

What are the ACID properties in Database Systems?

Taslan Graham — Wed, 28 Jul 2021 02:36:23 +0000

WHAT IS ACID

ACID stands for Atomicity, Consistency, Isolation, and Durability. It is a set of database properties(rules) which transactions must obey to maintain the integrity and consistency of a database. In this article we'll take a look at each ACID property.

But first, what is a transaction? A transaction is a single logical unit of work which accesses and possibly modifies the contents of a database. Transactions access data using read and write operations - GeeksForGeeks

Atomicity

With the atomicity rule all operations within a transaction must be successful in order for any changes to be commit to the database. If any failure occurs during a transaction then the entire transaction fails. Lets look at an example.

Imagine we have two bank accounts, account A and account B. Account A has $500, while account B has $100. We'll like to transfer $50 from account A to B. The transaction would like the following.

Lets imagine that a failure occurs right after we write the deductions to account A. This would leave account A with $450 but, account B was not updated. So we just magically lost $50. This would corrupt your data. The property of atomicity prevents this - once there's a failure anywhere in the transaction then the entire transaction fails - and nothing gets committed to the database.

CONSISTENCY

Database consistency must be maintained after each transaction. This means that all changes should be accurate, and leaves the database in a valid state which also upholds data integrity. Lets look at the following example.
Imagine we have the following two tables(customers, and orders).

Both tables are linked via the foreign key constraint based on the customer_id on the. This will ensure that upon inserting a new record in the orders table, the customer_id used is valid (is an id of an existing customer record in the customers table).

If a transaction inserts a new record in the orders table using a customer_id (e.g 90) that does not exist then the database would be in an inconsistent state as two. Thankfully our foreign key constraint would prevent this, and the entire transaction would be aborted(including any other changes that may have occurred earlier in the transaction) and consistency would be maintained.

ISOLATION

A transaction being executed should not be affected by any other transactions executing simultaneously, therefore isolated. The result of concurrent transactions should be the same as it would be if the transactions were executed sequentially. Isolation also determines how/if changes in an uncommitted transaction are visible to other transactions or whether different transactions can access the same data at the same time. - this is done via isolation levels.

Durability

Durability ensures that changes committed during a transaction persists permanently(stored in non-volatile memory), even if there happens to be a system failure or a power outage. Lets take a look at an example.
Lets says you're transferring funds from account A to account B, and right after completing the transaction the bank has a sudden power outage, the durability property would ensure that the changes made to both accounts are still stored.

The ACID properties ensure that we have a database with correct data at any given time. In this article we looked at each of the ACID properties - there impact and importance.

This is my first time writing about a database topic, hope you enjoyed it and found it useful. Thank you for reading. Until next time, think, learn, create, repeat!

What is the D.R.Y Principle?

Taslan Graham — Sat, 20 Feb 2021 17:51:55 +0000

In this article we will explore one of the main software design principles - D.R.Y, its benefits, and downfall of violating this principle. I will also provide short code snippet to help demonstrate this principle.

What is the D.R.Y Principle

D.R.Y, which stands for "Do Not Repeat Yourself", is a principle of software development aimed at reducing the of repetition code.

The Authors of the book The Pragmatic Programmer described D.R.Y as "every piece of knowledge must have a single, unambiguous, authoritative representation within a system."

Knowledge would be your business logic, and algorithms or a variable used in your application. So, in simple terms what the definition is saying is that every piece of individual logic or algorithm or info should live and be expressed in a single location(function etc.) within your code.

The alternative to this would be to have the same thing expressed in two or more places. If you change one, then you'll have to remember to change the others - and waste everyone's time.

D.R.Y Violation

Let us take a look at simple piece of code that violates the D.R.Y principle. We will then we update our code to adhere to the D.R.Y principle.

Let's imagine we have the following class:

class Player {
  constructor() {
    this.position = null;
  }

  moveRight() {
    this.position = "Right";
    console.log("Moved player -- Right");
    this.rest();
  }

  moveLeft() {
    this.position = "Left";
    console.log("Moved player -- Left");
    this.rest();
  }

  moveUp() {
    this.position = "Up";
    console.log("Moved player -- Up");
    this.rest();
  }

  moveDown() {
    this.position = "Down";
    console.log("Moved player -- Down");
    this.rest();
  }

  rest(){
    console.log("Taking a break...... Drinking some water :)");
  }
}

Our class has methods that allows a player to move left, right, up, and down. However, each method ( moveRight(), moveLeft(), moveUp(), moveDown() ) all repeats the same logic.

If we wanted to perform some more task after moving (similar to rest()) then we will have to update each of our existing methods to include that new piece of code. We could update our class to the following:

class Player {
  constructor() {
    this.position = null;
  }

  move(direction) {
    this.position = direction;
    logMessage(`Moved player -- ${direction}`);
    this.rest();
  }

  rest(){
    console.log("Taking a break...... Drinking some water :)");
  }
}

Here we updated our class to have a single move() method which will handle moving the player. We also included a function, logMessage(), which we'll pass our confirmation messages to. Let's imagine that this function is available for usage across our entire codebase.

Benefits of Keeping D.RY.

Adhering to the D.R.Y principle provides many benefits. Some of which are mentioned below. While reading these benefits you'll also get a picture of what life is like when you fail to follow the D.R.Y principle.

Maintainability

If you have repeated logic all over your application then it will be a nightmare to make updates. If you fix an issue or make an update in one place then you have to remember to make the changes in the other places - and we're likely to forget all the places that needs this fix. However, if we have our logic in one place then we only need to make a fix in that one place making our code easier to maintain.

Promotes code reuse

With the D.R.Y principle, logic that was expressed across two or more instances in now available at a single source. Whenever you need that piece of logic you can simply reuse the existing source (variable, function etc.).

Easier to test

If a piece of logic is duplicated across your application codebase then you'll need to write test to cover the various areas where the duplication is present. Having a single place test test makes would make testing much easier.

In this article we took a look at the D.R.Y principle, and it's benefits. We also got an insight into how difficult life can get when we violate this principle. We should always try to refactor and remove duplication from code as much as possible.

If you found this article helpful then leave a comment below. Also spread the knowledge with your peers by sharing this article. Until next time, think, learn, create, repeat!

Advice to Junior Software Engineers - from a Junior Engineer

Taslan Graham — Wed, 03 Feb 2021 15:13:54 +0000

As a Junior Engineer you're at the baby stages of your career - learning a lot, and full of passion. Recognizing that this is a time for growth you may ask yourself "what are the things that I can do during this important time in my career to help me along my journey?".

Here are eight (8) pieces of advice to Junior Engineers from me, a fellow Junior Engineer. The following has played a huge role in my journey thus far.

This list is a non-exhaustive, many more things can and should be done (for example, focusing on developing technical skills, learning different techniques and best practices. So, without further ado lets dive in.

1. Take notes from senior Engineers

There's a lot you can learn from experienced Engineers if you observe them or ask questions. Things like how to deal with clients and project managers, tips on how to improve as an Engineer, advice on how to progress forward in your career, problem solving, insight into different technologies and so much more.

Most seniors are happy to share what they know with you. You can also follow senior Engineers on social media as well. One Engineer who I follow on YouTube is Hussein Nasser, he discusses a wide range of engineering topics.

2. You Don't Need To Know Everything

There's a lot out there to learn in the world of technology. Some persons may feel doubtful of their skills, unready or inadequate if they don't know a particular thing or can't answer a particular question about something.

The truth is, you don't need to know everything. You simply need to know the things that are relevant to what you're doing.

Something to keep in mind is that you can learn just about anything tech related through proper research and usage of free resources like YouTube.

3. There's No Such Thing As Perfect Code

I used to spend a considerable amount of time overthinking and trying to perfect my code. Ironically this lead to code that was prematurely "optimized", over complicated and difficult to read, understand and debug.

Trying to write perfect code will slow you down. It's best to write working code in its simplest form then refactor to improve readability and performance.

4. Learn How To Read Code

I read something somewhere that said something along the lines of "you'll read more code than you write". This is quite true. You'll spend a considerable amount of time reading existing code ( written by yourself or others).

Adding a new feature to an application? You'll first need to read the existing code to understand what's going on.
Refactoring code? You'll need to read it first.

Searching for help online? You'll need to read and understand the code snippets given to avoid just copying and pasting.

Even when you're using a framework, you'll need to be able to read through the coding samples given in their documentation.

Seeing that you will spend a lot of time reading code, it makes sense to improve on this skill. Reading code written by others will help you to see the thought process of other engineers.

You can read open source code (at the time of writing, I don't read a lot of open source code but, I intend to change that) or code written by project team members. Reviewing PRs (pull requests) are also a great way to learn to read code.

5. Work On Your Soft Skills

It's well known that technical competence is needed to have a great career as an Engineer but, at the end of the day we are still social beings and we will work with others .

Even with work from home being the status quo, your people skills are still on display in the gazillion weekly meetings that you have.

How you interact with others(clients, teammates etc.) can open doors for you even in the early stages of your career.
You don't need to be chatty or extremely out going either. You simply need to develop certain soft-skills.

6. Learn The Tools You Are Using

An efficient craftsman knows his tools inside out - their capabilities, limitations and use cases. As an engineer you have to learn the tools you use on a regular basis. This includes your IDE, source control, project management tool and any other tool you use on a daily basis to carry out your work.

Learning and mastering these tools will make you much more efficient and can save time. For example, learning the shortcuts within your IDE will allow you to navigate your code and work faster.

This is a continuous process for me as I'm always coming across things I did not know about the tools I'm using.

7. Take Opportunities To Lead

A great way to get noticed within your organization and to be viewed as more than just another developer is to make the most of opportunities to lead.

This does not necessarily mean leading projects (in most cases, more experienced engineers lead the projects). Leadership can mean taking opportunities to lead project demos, review sessions, providing help to others, volunteering to be a part of discussions surrounding the project or product, contribute to in-house projects/groups, and doing your absolute best with everything you're tasked with.

These things shows that you take initiatives and that you care about what you are doing.

8. Keep Learning

Continuous learning is key in the world of Software Engineering. What's new today might become obsolete tomorrow, and at times we may be working on legacy systems using legacy technologies.

Therefore, we need to set aside some time to learn things we are interested in, and to level up on our skills (both technical and non technical). This can be done through reading, taking online courses and watching tutorials. This personal investment will payoff in the future. Also, find a way to share what you learn!

There you have it, eight (8) tips for Junior Software Engineers - from a fellow Junior Engineer.

I hope you found these tips helpful. Let me know you're favorite one as well any additional advice in the comment section. Until next time, think, learn, create, repeat!

Caching in NodeJS with Redis

Taslan Graham — Tue, 12 Jan 2021 14:33:10 +0000

Full post available here.

Speed performance is critical in modern-day applications. Most of the time your application may have to make requests to an endpoint/server to get some data. Or your application may frequently request a specific dataset.

Depending on the size of your dataset along with other things like query database and network speed, the speed at which your application can fetch certain data to display to users may get slower over time (as data increases).

This is where caching comes in handy and can dramatically improve your application's speed. In this tutorial we will look at how to implement redis caching in a node application (API) to improve the speed at which we are able to serve data to client apps. Let's dive in!

What is Caching

Before we dive into creating our own Redis cache, we have to first answer the question of what is caching?
In computing, a cache is a high-speed data storage layer which stores a subset of data, typically transient(existing for a short period of time) in nature, so that future requests for that data are served up faster than is possible by accessing the data’s primary storage location. Caching allows you to efficiently reuse previously retrieved or computed data - https://aws.amazon.com/caching/

Here's a scenario to help you think about how caching works. Imagine you're watching your favorite sport (Soccer/Football for me ) or the news or a movie.

You're also a big fan of Potato chips, so you decide that every 15 minutes you'll go to the kitchen to get a little potato chips to eat.

You then noticed that going to the kitchen every 15 minutes is time consuming, not to mention the fact that you miss out a minute or two of what you're watching.

So instead of repeatedly making trips to the kitchen you decide fill a large bowl with chips and have it right next to you while watching the TV.

Now you can get your chips much faster and you don't need to go back to the kitchen unless your bowl is empty or you want a different kind or chips/snack . That bowl of chips is your cache.

In the world of IT, caching is similar. Data is stored somewhere (the bowl) where it can be accessed fast without having to go to the original source (the kitchen) unless the data needed is not inside the bowl.

What is Redis

Seeing that we will be using Redis to implement caching inside our node application it makes sense to first discuss what is Redis. Redis is an in memory key value pair database. Yes, you read that right, Redis stores data in memory (RAM).
Reading and writing to RAM is magnitudes faster than reading from a disk drive. This makes Redis perfect for caching.

Benefits of caching

Redis cache uses RAM as its storage (more on this further down) which is faster than disk storage, reading from cache is extremely fast. Being able to read data at higher rates will significantly improve application performance.
Caching frequently requested data will result in a reduction in the number of database queries needed retrieved particular data.
Following up on the previous benefit, if we are making less database queries or even less network request to fetch external resources then our application will have lower latency.
Your application can scale better since you can cache that is requested more frequently as more person uses your application.

Node App

Now that we understand what caching is and got an introduction to Redis we will create a node application that utilizes caching through Redis.
Our application will be a simple e-commerce API server that allows users to fetch a list products. Let's start coding!

Create a folder name node-redis-cache (or whatever you like )
open the folder inside your text editor(I use VScode)

We'll be using a few npm packages in our app:

express - handle routing in our app
redis - use redis commands in node
axios - to make API calls

Open your terminal inside the project folder (node-redis-cache) and run the following command to install the needed packages:

npm install express redis axios

The command above installs the express, redis, and axios packages

Create Server

Now lets finally write some code. We'll first create our express server. Create a file name index.js.

Add the following imports to index.js

const express = require('express'); 
const app = express();
const axios = require('axios');
const PORT = 9000;

const redis = require("redis");
const cacheClient= redis.createClient(); // redis client used to interact with redis database

app.listen(PORT, () => console.log(`listening on port ${PORT}`));

We've created our server and set it to listen on port 9000. We've also required in the redis and axios packages which we'll use later on.

Route

Now we'll add a route that returns a list of products to the user. Add the following to index.js

app.get('/products', async (req, res) => {
  const { data } = await axios.get('https://fakestoreapi.com/products'); // This is a real API ;)
  return res.send(data);
});

Here we've created a route handler for /products that will return a list of products. We are making a request to an external API to get these products.

Lets assume that this external API also makes a database request get this list of products. As you can see, when a user requests the list of available products it may take a while for them to get a response.

API Speed (without cache)

Let's test our endpoint using postman (or your favorite API testing tool). This will show us the speed performance of our application without caching.

Without caching implemented our API request takes 1540 milliseconds (or 1.54 seconds) to be processed. Now let's add caching to our route handler.

Adding caching

Update the /products route handler to the following.

app.get('/products', async (req, res) => {
    const TIME_TO_LIVE = 1800; // 30 minutes as seconds

    cacheClient.get("products", async (err, cachedProducts) => {
        if (cachedProducts) {
            res.send(JSON.parse(cachedProducts));
        } else {
            const { data } = await axios.get('https://fakestoreapi.com/products');
            cacheClient.setex("products", TIME_TO_LIVE, JSON.stringify(data))
            return res.send(data);
        }
    });
});

Here, we are changing how our /products route handler operates. When we get a request to fetch for products, we first check to see if we already have that data available in cache.

If the cached data is available then we return that to the user. If there's no cached data available, we first make a call to the external API for the data. Then we cache the newly fetched data.

The setex() method allows us to set the Time To Live (TTL) for the cached data. This means that after the specified amount of time (in seconds) the cached data will be deleted. Finally we return the data to the user.

API Speed (with cache)

This will show us the speed performance of our application with caching implemented. Lets make a call to the API endpoint.

Whoa, wait, that's not much faster! Why is that so? On the first request, there's no data in the cache, so we'd have to the make a call to the external API which will take some time. The fetched data is then cached and is available on subsequent requests. So, let's make another request.

Now look at that! Our request took only 2 milliseconds (or 0.002 seconds). That's fast, very fast compared to when we don't have cache implemented.

As you can see, caching can significantly improve your application's performance. There's a lot more to redis caching and caching in general. If you're interested in learning more about caching and redis, see the following links:

https://aws.amazon.com/caching/

https://www.cloudflare.com/learning/cdn/what-is-caching/

https://wp-rocket.me/blog/different-types-of-caching/

https://redis.io/documentation

https://www.npmjs.com/package/redis

If you found this helpful leave a comment below and share with devs who will find it useful. Until next time think, learn, create, repeat.

JavaScript call, bind, and apply methods

Taslan Graham — Sat, 28 Nov 2020 18:48:38 +0000

Full post available here.

Each JavaScript function has access to the this keyword. The this keyword references the object to which the function belongs (remember, everything in JS is an Object).

This sounds straightforward enough but, things can quickly get tricky when working with this. Why? The value of this is determined by how/where the function was executed:

In a method, this refers to the owner object.
Alone, this refers to the global object.
In a function, this refers to the global object.
In a function, in strict mode, this is undefined
In an event, this refers to the element that received the event.

This means that if we are not careful we can lose the scope of this.

Luckily, all JavaScript function object has access to some very special methods which we can use to explicitly state what this should reference. These methods are bind(), call(), & apply().

Bind

The bind() method creates a new function that, when called, has its this keyword reference the provided value.


function greeting() {
  console.log(`${this.firstName} says hi!`)
}

const john = {
  firstName: 'John',
  lastName: 'Doe',
  age: 20
};

const johnGreeting = greeting.bind(john);

Above, we created the function greeting, then on line 11, we used the bind method to tell the function that the this keyword should point to the object john.

This then returns a new function which we store inside johnGreeting. We can then execute johnGreeting.

johnGreeting(); // John says hi!

The bind() method can also accept arguments. These will come after the this argument. Here's an example:

function greeting(country) {
  console.log(`${this.firstName} says hi! from ${country}`)
}

const john = {
  firstName: 'John',
  lastName: 'Doe',
  age: 20
};

Here our greeting function now accepts an argument, country. We can now pass an additional parameter to the bind() method.

const johnGreeting = greeting.bind(john, 'Jamaica');

johnGreeting(); // John says hi! from Jamaica

Call

The call() method calls a function with a given this. The difference between the bind() and the call() is that the call() method does not create a new function, instead it immediately executes the function. Here's an example:

function printName() {
  console.log(`${this.firstName} ${this.lastName}`);
}

student = {
  firstName: 'Taslan',
  lastName: 'Graham'
};

printName.call(student);// Taslan Graham

Here we created a function, printName, and an object student. We then, on line 10, executed the printName function by calling the call() method on it and passing student object as the this that printName should use.

Similarly to the bind() method, the call() method can accept arguments.

function printName(age) {
  console.log(`Name: ${this.firstName} ${this.lastName}, Age:${age}`);
}

student = {
  firstName: 'Taslan',
  lastName: 'Graham'
};

printName.call(student, 24); // Name: Taslan Graham, Age:24

Here our greeting function now accepts an argument, age. We can now pass an additional parameter to the call() method.

Apply

Like the the methods above, the apply() method calls a function with a given this. It is very similar to the call() method, the difference being that the apply() method accepts arguments as an array.

const student = {
  details: function () {
    return `${this.name}, ${this.class}`;
  }
}

const graham = {
  name: "Graham",
  class: "Intro to Computer Science",
}

console.log(student.details.apply(graham)); // Graham, Intro to Computer Science

Here we have an object, student, which has a method called details.

We also have another object, graham, this object does not have the details method, but we used the apply() method to tell the the details() method of student that its this value should point to the the graham object.

Note: bind() & call() can be used in the way apply() is used aboved.

The apply() method can also accept additional arguments. These are passed as an array.

function printName(...args) {
  console.log(`Name: ${this.firstName} ${this.lastName}, Age:${args[0]} Country: ${args[1]}`);
}

student = {
  firstName: 'Taslan',
  lastName: 'Graham'
};

const age = 24;
const country = "Jamaica";
printName.apply(student, [age, country]); // Name: Taslan Graham, Age:24 Country: Jamaica

Above, we passed an array holding age and country to our printName function. We use the rest parameters to capture this array, then we print the values from their respective indexes.

As you can see, the bind(), call(), bind() are very powerful when we want want to determine what the this value inside of a function should be. They all work similarly but with there own unique differences.

The bind() method creates a new function with the this value provided to it. While the call() method immediately executes a function with the given this value. Similarly to the call() method, apply() immediately executes the function with the given this value but, it accepts its arguments as an array.

Hope you found this helpful. Be sure to leave comments below on the interesting ways you've used call(), bind(), and apply().

Until next time, think, learn, create, repeat!

Creating JS objects that has no prototype

Taslan Graham — Tue, 17 Nov 2020 05:14:20 +0000

We know that All JavaScript objects inherit properties and methods from a prototype.

For example:
Date objects inherit from Date.prototype
Array objects inherit from Array.prototype

What if you want to create an Object that does not have a prototype?
Here's a neat little way to do it:

const blankObject = Object.create(null)

When creating objects using Object.create(), we can pass an object which will be used as the prototype for the newly created object. Alternatively, we can pass null which will result in an object being created without a prototype.

I only came across this recently. I think it's pretty cool and I may find some use for it.

Things tech students should consider doing

Taslan Graham — Thu, 22 Oct 2020 03:49:00 +0000

Full article can be found here.

Hey all! Welcome back. I hope you're all doing well. In this article, I want to talk about a few things that I believe university tech students should consider doing.
I've decided to write about this for two primary reasons, 1) as I start to approach the end of my time in university, I've started to reflect on what the past four years were like.
Things I did as a Student and things I didn't do. Secondly, a friend recently asked me "why should I do an internship?" and that got me thinking about what are the things that students should consider doing.

The following are some things that I've either done myself or witnessed other Students do, with great success during my time at university.

Attend Tech Conferences

Tech conference

Attending tech conferences is something that I love doing. Conferences provide a great opportunity for you to learn about current trends from industry experts, network with said experts and others.
An exciting thing about some tech conferences is that they highlight information technology's role in propelling other industries forward.
This has helped me to fully appreciate the level of impact that information technology can have when combined with other industries. So, if you want to learn about current trends, meet experts, and see technology's impact across multiple industries then you should definitely attend conferences.

Some conferences are expensive, so you should consider volunteering at a conference, or going to the ones that are free or within your budget.

Join tech groups/communities

Tech group

This is something I've started doing in the last twelve (12) months. I've join joined Google Developers Group(Kingston, Jamaica) and Facebook Developer Circles (Kingston, Jamaica) in my area.
Joining a tech group allows you to meet like-minded individuals, have insightful conversations, hear about different technologies, and learn from professionals and hear them talk about their experiences.
This may create a job opportunity for you. Tech groups may also create an opportunity for individuals to collaborate.
Recently, at Google Developers' Group meetup, a friend of mine spoke about an application he was working on, and someone immediately expressed interest in collaborating with him!

Participate in hackathons

Me(red shirt) at last year's Coder of the Caribbean Hackathon.

Hackathons are fun and provide an opportunity to solve real world problems.
Hackathons teaches you how to create under pressure, work in teams, and compete. All while having fun. I talk more about hackathons in a recent article, Why tech students should participate in hackathons. Give it a read to learn more about the hackathon experience.

Seek Internships

Intern using computer

Internships have provided the most value to me over the past year. Internships can be very important to your success in the professional world after university.
A quality internship allows you to apply the concepts learnt in the classroom in a real world environment while achieving personal growth, and learning new tools, technologies and concepts.
You'll also meet great co-workers and make new friends within the tech industry.

For most internships, you'll be working on a product which will be delivered throughout or at the end of the internship period.
An important thing to note is that internships can create an opportunity for employment after graduation.

I've written about my personal internship experience here, reflections on my first internship.
If you'd like to know how to land internships, then read Deandrew's article on finding interships

Pursue interests outside of tech

Taslan holding camera

Yes, you read that right. It is important to pursue your interests outside of tech. Love volunteering? Do it.
Love taking pictures, debating, teaching others, playing a sport? Whatever it is, pursue those interests outside of tech.
This will create new experiences for you, you'll meet people with similar interests. You may even be able to merge one of your interests with technology.

For me, my main interests outside of technology at the moment are photography and videography.
Recently I've also joined an organization name Youth Can Do I.T, which aims to use technology and strengths based initiatives to develop and empower the youth.
This has allowed me to pursue a long lasting interest of mine, improving digital literacy.

Bonus - Make use of opportunities that allows you to travel

At the start of my third year in university I started to realise that there are a lot of opportunities available to university students to travel (international & domestic) while pursuing their interests.
Take the opportunity to travel, while in university, at least once. I know persons who got to travel on numerous occasions by taking advantage of opportunities available to university students.
I've also had the opportunity to travel halfway around the world, and visit the headquarters of a fortune 500 company, free of cost!

That's it, the things I believe tech students should considering doing while in university. Attending tech conferences, joining tech groups/communities, participate in hackathons, seeking internships, pursuing your interests outside of tech, and taking advantages of travelling opportunities all have potential to enhance your university experience.

What is localStorage?

Taslan Graham — Sat, 26 Sep 2020 18:08:32 +0000

Full article can be found here.

LocalStorage is a web storage which allows you to store and access data as key:value pairs inside a Web Browser using JavaScript. Data stored with localStorage is permanent and stays forever unless deleted manually or programmatically .

In this article we will look at the five (5) methods available when using local storage, the benefits of localStorage and things to consider when using it.

Methods

As mentioned above, you have five (5) methods available when working with localStorage. These are:

setItem() - saves a key:value pair to localStorage
getItem() - retrieve an item in localStorage via a key
removeItem() - deletes the item for the given key
clear() - deletes all items
key() - returns the key at the given index

Before we look at each method, it is important to understand that the localStorage operated on will be the current domain from which the methods are executed.

**setItem(key, value)**

You use the setItem method to store new data inside localStorage. It accepts a key and a value.

localStorage.setItem('school', 'University of Technology, Jamaica');

The above code will create a key named school and store it with the value university of Technology, Jamaica.

Storing Objects in localStorage

It's important to note that localStorage can only store string values. If we want to store an object, we have to first convert it to a string value. We do so using the JSON.stringify() method.

// Create user object

let user = {
  name: 'Taslan Graham',
  nationality: 'Jamaican'
};

localStorage.setItem('user', JSON.stringify(user)); // Stores user as JSON string

The above will convert the user object to "{"name":"Taslan Graham","nationality":"Jamaican"}" and store it.

**getItem(key)**

The getItem() method accepts a key and returns its value.

localStorage.getItem('school');

This will return 'University of Technology, Jamaica'.

We can also retrieve the user item stored earlier.

let user = localStorage.getItem('user');

This returns "{"name":"Taslan Graham","nationality":"Jamaican"}". We can convert this JSON string value back into a JavaScript object.

JSON.parse(user); // {name: "Taslan Graham", nationality: "Jamaican"}

**removeItem(key)**

The removeItem method accepts a key and deletes it from localStorage, if it exists.

localStorage.removeItem('school');

clear()

The clear method will delete all data inside localStorage for the domain.

localStorage.clear();

key()

The key method accepts a number(n) and returns the nth key inside in the localStorage object;

localStorage.key(0)

The above code would return the first key inside localStorage.

The key method can be useful when we want to access each key inside localStorage without knowing their names.

for(const i = 0; i < localStorage.length; i++){
  const key = localStorage.key(i);
  console.log(localStorage.getItem(key);
}

In the above code, we start looping at zero and for each iteration we use the value of i to retrieve the key at that position inside localStorage; we store the key inside the key variable. We then log the value of the current key to the console.

Benefits of localStorage

localStorage provides some very interesting benefits. These includes:

1. localStorage is supported by the major modern browsers.

This means you can use it within your app without worries.

But, if you want to ensure that the user's browser supports localStorage, you can do the following.

if (typeof(Storage) !== "undefined") {
    // Write code for localStorage here
    } else {
     // No localStorage support
    // Do something else
}

2. Can be used for simple caching

Most browsers provides up to 10MB for web storage. This means you could use localStorage for caching data which rarely changes and is accessed often throughout your application.

3. The data can be accessed easily and quickly

You can retrieve data without making a network call.

Things to consider

When using localStorage there a couple of things to take into consider. Well, they are more like thing not to do when using localStorage.

1. Don't store sensitive data in localStorage

There's no security associated with localStorage. Anyone can view the data. Therefore , it is not suitable for storing sensitive information such as user passwords.

2. You may still need an actual database

The data stored is localized to the user's browser and is only accessible there. Therefore localStorage is not a substitute for a database.

In this article we covered localStorage, and the methods available when working with it. Additionally, we looked at some benefits of localStorage as well as some things to take into consideration when using localStorage.

If you enjoy this article, leave a comment about what was most valuable to you. Also share with friends who might find it useful.

Until next time, Think, Learn, Create, Repeat!

Keep at it

Taslan Graham — Wed, 23 Sep 2020 06:44:20 +0000

Full article can be found here.

Dealing with doubt and change as a techie.

With a pat on my shoulder, the teacher looked at me and said "keep at it!". What? I asked myself. Am I coming to university to hear such nonsense from a teacher?

At that time I had no idea how impactful this simple phrase could be. As I progressed through university, learnt new skills, and grasp abstract concepts in courses, I noticed the increasing frequency at which I had to tell myself "keep at it". Maybe my teacher was on to something!

Hey all, welcome back! I hope you and your family are all safe during this pandemic. Recently, I've been thinking a lot about the the battles young tech students, and professionals face. Therefore, I'm writing this article to discuss some of those battles and how you can overcome them.

There are two specific challenges that I want to discuss, namely self-doubt and dealing with changes.

Self-doubt

In simple terms, self-doubt can be defined as a feeling of uncertainty regarding certain aspects of yourself, such as your skills or talents.

Self doubt can be crippling to anyone's progress throughout life.

With the nature of the tech industry, letting self doubt run free will most certainly result in you losing out on opportunities, relationships, and much more. Understanding your doubts, and learning to deal with them can be empowering.

Self doubt may appear in different forms. You may find yourself saying things like "am I good enough or ready to do this?", "will I be able to complete task?", "are my skills enough to apply for this internship".

You may even notice some levels of anxiety, procrastination, and difficulty making decisions when you're experiencing self doubt. For me, I tend to ask myself "can I do this?".

That's how I know that some form of self doubt is creeping in. So, how does one cope with self doubt?

These are some simple techniques that I've found to be helpful:

Change the way you view self doubt

It is important to understand that some level of self doubt is normal when you are faced with new or challenging situations.

Use self doubt as an indication to self assess and identify the areas/skills that you may need to improve on in order to accomplish the initial goal that triggered the doubt.

Use past success to push yourself

If you look back, you'll definitely find a past experiences where you had some level of doubt, but still propelled above it. Use these experiences as a source of strength to overcome your current situation.

Take action

“Doubt can only be removed by action.”
Johann Wolfgang von Goethe

After you start to work on something you'll start to notice that your doubts gradually dissipates. Personally, this is something I keep in the back of mind, "doubt can only be removed by action".

So I do my best to take action regardless of my doubts, knowing that eventually, at some point, the doubt will fade away. Then, surprisingly at the end of it you realise that it really wasn't as bad as you thought.

For example, in 2018 I worked as a software developer for the first time. I was tasked with implementing an image cropper as a feature within a web application.

At first I was uncertain about my ability to complete this task, but I worked on it regardless. Eventually, the doubt faded, and soon thereafter the feature was implemented.

Ironically, at the time of writing this, a friend reached out to me asking for assistance in implementing an image cropper with the same framework & library I used in 2018.

Dealing with changes

Changes are inevitable, and it seems to happen every hour in the tech industry. It can be a daunting task for tech students, and professionals to keep up with or adjust to the changes happening. However, it is important be able to do so. So, how do you manage changes?

Here's some tips that may work:

Be open to change

Never make the mistake of becoming overly attached to a particular technology, language, framework, or process. This will make you a bit resistant to using an alternative.

Thus, making it harder for you to adjust accordingly in the event that what you're using has suddenly becomes obsolete (which could happen before you finish reading this), or there are truly better alternatives which you should consider.

Without having to go into details, I can confidently say that the current pandemic has taught us all to be open to change.

Fall in love with learning

Being a part of the tech industry means that you will be continuously learning something new in order to get things done.

Learning is an everyday aspect of this industry, and changes usually means you have to learn something new. A new language, framework, way of doing things, way of thinking, or something new about the things you already know. You simply have to love learning so that you can stay atop of things.

This doesn't mean we should try to learn everything there is. I was once like that. Learning something takes time and effort, so you should ensure that the decision to learn something is an informed one or one that simply had to be made.

Follow experts on social media

Follow industry experts on social media to get insights into what's happening or is about to happen. Experts are usually on top of the different shifts happening in the industry.

For example, I follow JavaScript experts on twitter see their views on things related to the language. When they discuss certain techniques I think about how I can change the way I'm doing certain things to incorporate these techniques.

Doubts, and changes can prove difficult to handle. I have shared some things that I do to deal with both doubt and changes. Regardless of the challenges you may face in dealing with both doubt and change, it is important to stay on course, never give up. Simply, keep at it!

I hope you found this helpful. Until next time, think, learn, create, repeat.

Found this article useful?