DEV Community: Royce

Java as a Second (or third) language

Royce — Wed, 06 Jul 2022 19:42:53 +0000

I started my coding journey a little under a year ago and when I was deciding on which language I wanted to learn, several people stated, “It doesn’t really matter which language you pick; just pick one and stick with it”. Of course, others named specific languages for various reasons, “Choose Python because the syntax is the most beginner friendly” or “Choose C or C++ because learning those will give you a better understanding of programming as a whole”. Both are valid points. I happened to choose JavaScript (which is to be differentiated from Java) because I saw it as the pragmatic choice, that which could land me a job the quickest (being one of the most widely used programming languages out there). Recently, I began exploring other languages and tossing around the idea of which I’d like to take on as a second language. I’m not certain that I’d take on this challenge immediately but it exciting to poke around and see what’s out there. After exploring, the language that kept sparking my interest was Java. After doing some research I thought it might be nice to present my findings to other beginner/intermediate programmers curious about the Java programming language.

History

Java is a class-based (more in this later), object-oriented programming language, multithreaded programming language, designed to have as few implementation dependencies as possible. Considered a general-purpose language, it was created with the motto “write once, run anywhere”, meaning after compiled it can run one any platform that supports Java. Java was developed in the early 1990s by James Gosling, and his team, at Sun Microsystems. It was originally designed for interactive television but was too advanced for the industry at the time, it was best suited for internet programming and later incorporated by Netscape. Java is largely inspired by the C language family and shares similar syntax so that programmers would recognize it more easily. It is architecture neutral and dynamic and runs on everything from laptops to data centers, game consoles, and supercomputers.

Getting Started

Writing your first Java program is relatively straight forward. If you use VSCode as your IDE, download the Java Extension Pack, open the command prompt Ctrl + Shift + P and enter the command Java: Tips for Beginners to download a Java Development Kit (JDK). I'm going to use Eclipse Adoptium's Temurin. After it's installed, create a source code file.

Create a folder for your Java program and open the folder with VS Code. Then in VS Code, create a new file and save it with the name Hello.java. When you open that file, the Java Language Server automatically starts loading, and you should see a language status item with a loading icon on the right side of the Status Bar showing the language status is busy. After it finishes loading, you can hover on the language status item and find the loading process has been finished successfully. You can also choose to pin the status item in the status bar.

Class vs Prototypal Inheritance

Before we get to the actual code, I pertinent to cover this topic quickly. Java is class-oriented language, which means that each object inherits the methods prom a previously defined class (either designed into the language or created by the programmer) to be used in subclasses. JavaScript on the other hand (prior to ES6) is prototype-oriented (and I'd argue, at it's core still prototypal but I'd need to personally look into the further). Back to Java-- as a class-oriented language, all Java source files must not only contain a public class (where all the coding happens), they must also take the same name of that public class. So if we wanted to create a Java program that prints "Hello World", we'd name it HelloWorld.java and create a public class called HelloWorld ...

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");//<- prints "Hello World"
    }
}

And there we have our very first Java program. I definitely excited to continue learning about Java and I hope you've learned a little today as well. I'll keep you posted on my progress 🚀

Further Reading:
Java Point
University of Helsinki’s free massive open online course

A brief introduction to NestJS

Royce — Tue, 28 Jun 2022 17:38:00 +0000

What is NestJS and why you should choose it for your next project?

NestJS is a Node.js framework intended to be used with TypeScript to build scalable and efficient server-side applications. It is open-source, progressive, easily extensible, and quickly gaining popularity among developers. Under the hood, Nest makes use of Express, another HTTP server framework, but can also be configured with Fastify. Nest can easily be integrated with any SQL or NoSQL database and provides integration with TypeORM (Object–relational mapping tool for Typescript) right out of the box for convenience. NestJS is noticeably influenced by Angular and the two would be a perfect pair for anyone’s next full-stack application.

Kickstarting your next project

Getting started with NestJS simple. You can either scaffold the project using the Nest CLI or clone a starter project. I am going to initiate a project using the CLI (documentation is linked below for additional details).

$ npm i -g @nestjs/cli 
$ nest new project-name

After running these commands, the Nest CLI will scaffold your new project, create a new project directory, and populate the directory with the initial core files and supporting modules. Alternatively, you can install the core dependencies found in the docs (linked below) and build your project from the ground up.

  src
   ├── app.controller.spec.ts
   ├── app.controller.ts
   ├── app.module.ts
   ├── app.service.ts
   ├── main.ts

Building Blocks

If you've used Angular before this should look familiar and you'll probably feel right at home using Nest. To get our feet wet using NestJS, we're going to build a basic REST API using Nest. We'll also use a basic MongoDB database and Postman to test our endpoints.

Controllers
The Controller is the routing mechanism responsible for handling incoming requests and returning responses to the client. Well start by defining our DTO (data transfer object) since we're using Typescript. The DTO defines how the data will be sent over the network.

// create-item.dto.ts
export class CreateItemDto {
  readonly name: string;
  readonly qty: number;
  readonly description: string;
}

We'll also throw together our interface and Mongo Schema while we're at it..

// item.interface.ts
export interface Item {
  id?: string;
  name: string;
  qty: number;
  description?: string;
}

The id and description in the interface is optional because mongo will provide an id us and not every item may have a description.

// item.schema.ts
import * as mongoose from 'mongoose';
export const ItemSchema = new mongoose.Schema({
  name: String,
  qty: Number,
  description: String,
});

Now, we'll build out our controller then discuss what everything means.. (To use the CLI to generate a controller template, execute $ nest g controller items )

// items.controller.ts
import { Controller, Get, Post, Put, Delete, Body, Param } from '@nestjs/common';
import { CreateItemDto } from './dto/create-item.dto';
import { ItemsService } from './items.service';
import { Item } from './interfaces/item.interface';

@Controller('items')
export class ItemsController {
  constructor(private readonly itemsService: ItemsService) {}

  @Get()
  findAll(): Promise<Item[]> {
    return this.itemsService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id): Promise<Item> {
    return this.itemsService.findOne(id);
  }

  @Post()
  create(@Body() createItemDto: CreateItemDto): Promise<Item> {
    return this.itemsService.create(createItemDto);
  }

  @Delete(':id')
  delete(@Param('id') id): Promise<Item> {
    return this.itemsService.delete(id);
  }

  @Put(':id')
  update(@Body() updateItemDto: CreateItemDto, @Param('id') id): Promise<Item> {
    return this.itemsService.update(id, updateItemDto);
  }
}

At the top we have our imports, all of which should look familiar except ItemsService which we'll build and discuss next. Then we have our @Controller() decorator, which defines our controller, establishes our endpoint /items and conveniently allows us to group our related routes. The @Get() HTTP decorator tells Nest to create a handler for a specific endpoint for HTTP requests. The @Body and @Param decorators are equivalent to req.body and req.param in Express. Nest handles that for us under the hood. findAll(), findOne(id), create(createItemDto), delete(id), and update(id, updateItemDto) are service methods we'll define in our Provider.

Providers
In Nest, Providers can be injected as dependencies into other components and create various relationships with each other, basically "wiring up" instances of objects. Controllers handle the HTTP requests and we can delegate the more complex tasks to the Provides. There are different types of providers— services, repositories, factories, helpers, and so on. We're going to build a basic service to allow us to interact with our database. After, we'll incorporate everything in our Module.
(To use the CLI, execute $ nest g service items )

// items.service.ts
import { Injectable } from '@nestjs/common';
import { Item } from './interfaces/item.interface';
import { Model } from 'mongoose';
import { InjectModel } from '@nestjs/mongoose';

@Injectable()
export class ItemsService {
  constructor(@InjectModel('Item') private readonly itemModel: Model<Item>) {}

  async findAll(): Promise<Item[]> {
    return await this.itemModel.find();
  }

  async findOne(id: string): Promise<Item> {
    return await this.itemModel.findOne({ _id: id });
  }

  async create(item: Item): Promise<Item> {
    const newItem = new this.itemModel(item);
    return await newItem.save();
  }

  async delete(id: string): Promise<Item> {
    return await this.itemModel.findByIdAndRemove(id);
  }

  async update(id: string, item: Item): Promise<Item> {
    return await this.itemModel.findByIdAndUpdate(id, item, { new: true });
  }
}

Following the imports, we notice the @Injectable decorator. The @Injectable decorator attahces metadata which declares that ItemsService is a class that can be managed by the Nest inversion of control (IoC) container. The rest of the code is pretty straightforward, using Mongoose methods to query our database. Going back to our controller quickly we inject it inside our constructor (if we haven't already, which generally we wouldn't have until we created it).

// items.controller.ts
@Controller('items')
export class ItemsController {
  constructor(private readonly itemsService: ItemsService) {}

We take note of the private syntax which allows us to both declare and initialize ItemsServer immediately in the same location.

Modules
A Module is denoted with the @Module decorator and provides metadata that Nest uses to organize the application structure. Each application at least one module, a root module, usually app.module.ts, and serves as a start point Nest uses to build the application graph - the internal data structure Nest uses to resolve module and provider relationships and dependencies. In our case we will have one feature module, ItemsModule, and our root module AppModule.
(To use the CLI, execute $ nest g module items )

// items.module.ts
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { ItemsController } from './items.controller';
import { ItemsService } from './items.service';
import { ItemSchema } from './schemas/item.schema';

@Module({
  imports: [MongooseModule.forFeature([{ name: 'Item', schema: ItemSchema }])],
  controllers: [ItemsController],
  providers: [ItemsService],
})
export class ItemsModule {}

// app.module.ts
import { Module } from '@nestjs/common';
import { ItemsModule } from './items/items.module';
import { MongooseModule } from '@nestjs/mongoose';
import config from './config/keys';
const { MONGO_URI } = config;

@Module({
  imports: [ItemsModule, MongooseModule.forRoot(MONGO_URI)],
})
export class AppModule {}

Assuming you have your database set up and have a URI in your config directory, you should be able to fire up the app with $ npm start and use Postman (or your preferred API testing software) to test out your first NestJS server side application.
I hope you give NestJS a try on you next project. I know I will. 🚀

Links:
NestJS Documentation
Dependency Injection and Inversion of Control in JavaScript

What is GraphQL

Royce — Thu, 23 Jun 2022 20:04:44 +0000

How you ever wondered, “I wish there was a way I could query an API without getting a bunch of unnecessary data?” Well, you might be interested in GraphQL. “What is it?”, you ask.
I've seen heard it mentioned on blogs and videos (it should be mentioned that I'm an intermediate learner and my course-load until recently was chosen for me), never really giving it much thought. Then I decided to investigated.

GraphQL is a query language for your API, and a server-side runtime for executing queries using a type system you define for your data. GraphQL isn't tied to any specific database or storage engine and is instead backed by your existing code and data. A GraphQL service is created by defining types and fields on those types, then providing functions for each field on each type.
– Introduction to GraphQL

I've seen heard it mentioned on blogs and videos (it should be mentioned that I'm an intermediate learner and my course-load until recently was chosen for me), never really giving it much thought. Then I decided to investigate.

Comparing to REST API

So, I can use GraphQL to query the data from an API. How is that different from the standard http methods like GET, POST, PATCH, PUT, and DELETE? GraphQL uses different methods called Query, Mutation, and Subscriptions.

Query

In GraphQL, query is used to fetch data from the data store like a GET request in a REST API. The difference is how GraphQL is set up and how much of the data to request from the endpoint. In the dataset below, we have a dataset of customers which could potentially be very large.

We, however, only need their names and ages in this case, so that's all we query. That's the appeal of GraphQL. Like everything, there's usually a drawback but we'll get to that in a bit.

Mutations

Mutations are ways to change data using GraphQL, like POST, PUT, PATCH, and DELETE. If we wanted to add, change, or remove from our data we would use a mutation.

Notice here we are adding "Harry" to our customer list by specifying which fields to add (and only those will get added).

But then we decide to remove to remove Harry for whatever reason (sorry Harry). We only need to provide his Id.

Getting Started

Getting setup to use GraphQL is straightforward. Below is just a basic server setup with express. But GraphQL is compatible with many different
architectures and languages. If we went to localhost:400/graphql in our browser, we would get to the "GraphiQL" UI we saw above
because we set it in our instance graphiql:true.

Schema
Now that we have our server set up we can define a basic Schema and type out the fields in out data set. We start by instantiating a GraphQLObjectType and define each field. In this case we're using basic types GraphQLString and GraphQLInt but there are others as well.

After the types we'll set our RootQuery and Mutations.

There's a lot happening here so let's go over it quickly. We start with a GraphQLObjectType like we did for CustomerType and for each field, in this case of the RootQuery, customer and customers, we'll have a resolver, which essentially does the heavy lifting. For the Mutation we do basically the same thing with the addCustomer,
deleteCustomer, and editCustomer fields. If we want a value to be required, we wrap with the GraphQLNonNull type. After we're done, we export inside GraphQLSchema and we're well on our way.

To REST or not to REST

When should you use GraphQL vs http? I would say it depends on the side of your project and
the size of the data set you want to access. The benefit of GraphGL is that it tends to be faster because its return less data; Worth it if you want to scale your project and the data you want to access has a lot of info you don't need. Conversely, REST API are compatible with all browsers and have been around for longer, has better error handling, and built-in caching. GraphQL error handling is lacking, and caching must be set up manually. GraphQL is new and shiny and has real potential. REST is old and trusted. So, take your pick. Good hunting.

Links:
https://graphql.org/
https://github.com/royce-reed/graphQL-demo

Continuous Integration and Continuous Delivery

Royce — Tue, 14 Jun 2022 14:09:51 +0000

"What is Continuous Integration and why is it important?" If you are novice programmer, you may be asking yourself these same questions. CI/CD stands for Continuous Integration and Continuous Delivery (or Deployment) used in DevOps (Software Development and IT Operations). CI/CD is a best practice where developers can frequently deploy code to production, without having to wait for manual approval, or worse waste a ton of time testing code manually. It allows developers to spend more time writing code and less time testing locally and manually deploying.

The Pipeline

If a developer is working on a feature and they want to make sure it is working correctly before they deploy it, without CI, they might have to run a series of tests locally or have print statements (console.logs) littered throughout their code base to ensure it's working. This process can take a lot of time and can be a lot of work. With CI, a developer can run a single command to check that the application is working correctly. This way the developer can spend more time writing code and less time testing. When merging or submitting a Pull request, the CI server will run the tests and if they pass, the code would be allowed to be merged into the master branch (or another branch).

Continuous delivery extends the idea of continuous integration to also include the process of deploying code and updating the live environment (or a staging area) after the build/testing stage. In addition to automated testing, you have an automated process that can deploy code with the click of a button. This can improve the deployment process so that develops can deploy code in small batches and test of debug more efficiently

Continuous deployment takes the process one step further, allowing every change that passes all the previous stages of the pipeline to be released to the live environment. Only a failed test would prevent the change to be deployed.

GitHub Actions

There are several different CI tools available to pick from. Popular ones include Jenkins, Travis, Gitlab and others. I will not go into too much detail about them, but they all have their pros and cons. Being that prefer to do as much as possible with the tools I use, I prefer GitHub Actions. It is easy to setup, and it is right in the browser.

Let us do a quick demonstration of how easy it is to set up GitHub Actions …
Open the terminal and cd into your repository’s root folder, then create a .yml file touch .github/workflows/action-demo.yml. In the .yml file we're going to paste some boilerplate code we got from the GitHub Actions Documentation. We will also add a couple lines at the bottom to install our dependencies and run our tests.

name: GitHub Actions Demo
on: [push]
jobs:
  Explore-GitHub-Actions:
    runs-on: ubuntu-latest
    steps:
      - run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
      - run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub!"
      - run: echo "🔎 The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}."
      - name: Check out repository code
        uses: actions/checkout@v3
      - run: echo "💡 The ${{ github.repository }} repository has been cloned to the runner."
      - run: echo "🖥️ The workflow is now ready to test your code on the runner."
      - name: List files in the repository
        run: |
          ls ${{ github.workspace }}
      - run: echo "🍏 This job's status is ${{ job.status }}."
      - run: npm i
      - run: npm test

After we've written our code (in this case a simple arithmetic
function) and run our code locally, we're ready to push our code and open a pull request. from the terminal git push --set-upstream origin test (we are on the test branch). At GitHub we see an indication our code was pushed up and GitHub suggests a PR. How convenient 😎

We can see the process in action

And when it's done we can successfully merge our changes..

Then delete our branch...

And that is all there is to getting started with GitHub Actions. See how easy it was? I hope this helps you include CI/CD in your next project.

What is WebSocket?

Royce — Tue, 07 Jun 2022 11:25:35 +0000

HTTP (Hypertext Transfer Protocol) and WebSockets are both TCP/IP (Transmission Control Protocol/Internet Protocol) based connections that are used to communicate from a client to a server or from one server to another. They are both used for different purposes and have different use cases.

What is HTTP protocol?

HTTP is a unidirectional TCP connection protocol that is used to send and receive data. When a client sends a request to a server, the server sends an appropriate response back to the client. After sending the response, the connection is closed. Each time a new request is made, a new connection is established and after the response is sent, the connection is closed. This is repeated every time a new request is made. This is known as stateless protocol.

What is WebSocket?

Unlike HTTP, a WebSocket connection is bidirectional, which means that the connection is open for both sending and receiving data. This is known as stateful protocol. WebSocket is a full duplex protocol, meaning that data can be sent and received at the same time. After closing the connection by either the client or the server, the connection is no longer open for data transmission. In contrast to HTTP, WebSocket starts with ws:// or wss://.

When to use WebSocket

      There are a number of use cases where WebSocket can be used in favor of HTTP. Let’s take a look at a few of them. WebSocket is a great way to implement real-time applications, such as chat, games, and real-time data transfer.
      A good example of one such real-time application is a stock ticker or stock trading website. A connection would need to remain open in order to send and receive data in real-time to get the latest price of a stock.
      A gaming app is another good example of the need for real-time communication for seemingly obvious reasons. You wouldn't want to play a game that had to refresh the UI every time new information was sent or received.
      And finally, the almost obvious example of real-time communication is a chat application. This is probably the most common use case for WebSocket. A chat application would need to remain open to send and receive messages in real-time.

When NOT to use WebSocket

WebSocket is best suited when we need real-time updates or continuous connection between client and server. If we simply need to fetch old data and send new data then HTTP is the way to go. Older data which isn't updated on a regular basis can be fetched using a simple GET request. Newer data can be sent using a simple POST request. This is a good example of when to use HTTP instead of WebSocket.

I hope this article has helped you understand the difference between HTTP and WebSocket and when to use each one. If you are interested in learning more about HTTP and WebSocket, I suggest you check out some of the following resources:

Why is the WebSockets protocol better?
WebSocket - MDN
WebSocket - Wiki

A brief introduction to the R programming language

Royce — Sun, 01 May 2022 19:31:31 +0000

What is the ‘R’ programming language?

R is a multi-paradigmatic (procedural, object-oriented, functional, and more) programming language used for statistical computing and graphics. It was created between 1991 - 1995, at the University of Auckland, by statisticians, Ross Ihaka and Robert Gentleman. R is used among data scientists and statisticians for data analysis and developing statistical software. It also possesses and intensive catalog of statistical and graphical methods, which include machine learning algorithms, linear progressions, and statistical inference to name a few.^[1]
R is open-source, free software, within the GNU package (notable software packages developed by the Free Software Foundation as part of the GNU Project). R is used not only by academics but by a variety of other industry including healthcare, government, insurance, and finance. Some notable large companies include Uber, Facebook, Google, and many more.

Use Cases

R offers a variety of statistics-related libraries and an environment favorable for statistical computing and design. In 2021, R ranked in the top five programming languages for data analysists and research programmers. Some real-world applications of R being used could be optimizing a financial portfolio, processing marking data, or even analyzing outcomes of clinical trials. R is more than just a programming language; R’s official software environment has built in visualization capabilities making it easy to plot data. It has an extensive community of useRs that have created an extensive set of packages that can be used for almost any data processing task.

Pros and Cons

What are some of the pros of using R versus other languages?
Open-Source: It is open-source and free, which means useRs can contribute to the development of R by optimizing packages, develop new ones, and resolve issues therein.
Analysis: R was specifically designed for statistical analysis which means it can perform a variety of machine learning algorithms such as classification and regression.
Packages: R provides packages and feature for developing neural networks. Its data visualization capabilities are quite capable as well. There are various libraries, such as ggplot2 and plotly, which allow for visually appealing graphs which set R apart from other languages.

What are some of the cons of using R versus other languages?
Learning Curve: R is a complicated language and has a steep learning curve and could be difficult for those to pick up without prior programming experience.
Security: R lacks basic security found in other languages. As a result, there are restrictions on R as it cannot be embedded into web applications.
Speed and Memory: in R, objects are stored in physical memory and utilizes more than other languages. It requires data to a single place which is in the memory. Algorithms in R are spread across packages, which makes it slower than other languages more contribute to its difficulty to implement algorithms.

R vs Python

As this is primarily an article about R, I will not do a proper comparison between the two languages, but simply point out some key differences.

R is difficult to learn in the beginning but has more specific applications for statistical analysis, while Python Is more beginner friendly but that in and of itself limits what it can do regarding analysis.
The primary objective of R is data analysis and statistics whereas the primary objective of Python is development and production.
R is integrated to run locally whilst Python is well-integrated into apps This is just to name a few but there might be several reasons to pick one language over another, depending on each projects’ needs.

Version control – ‘Git’ with the program

Royce — Mon, 25 Apr 2022 12:56:59 +0000

History
If you have done any work with computers or on a computer file, at some point you had to save a file in some form or another. Most people might simply press ctrl+s to save work. But what if you need to keep track of the changes made to certain files or projects? Or better still, what if multiple people ore working on the same project, file, or collection of files and need to keep track of who changed what and when, and what the specific changes were? Version Control Systems (or revision control system) is the answer.
What is a version control system? A version control system or VCS is a system that records changes to your files or projects that can be used individually or share with members of a team (as you might have guessed). Prior to 2005 there were various VCSs all vying for a seat the preverbal table. Each had unique features, but most were closed-sourced and ran on client servers. This might work for a cooperate environment of a couple dozen or so people working on a single repository, but what of hundreds or even thousands working on a massive project? Enter Linus Torvalds.

Out of many… One
In the late 1990s Torvalds and various contributors were developing the Linux Kernel (the part of the operating system that acts as an intermediary between the computer hardware and the applications) and were struggling with revision management. Given the scale of such a project, one can only imagine. In 2002, the team adopted a VCS called BitKeeper, a commercial product, was free under certain conditions. For assorted reasons, the company behind BitKeeper decided to discontinue the free version. There were also grumblings from proponents of open-source software about using a proprietary tool to develop open source. ^[1]
After searching for another off-the-shelf solution to his problem yielded few options, Torvalds developed the first version of Git in 2005 (it is said) in a matter of days while taking a working holiday. His cited reasons for creating a new VCS were that he needed that could manage the number of contributions in a reasonable amount of time. Since then, Git has grown into the premier version control system with over 85% of developers using the software (according to this recent survey).

Further Reading: History of Git, The Road to Domination in Software Version Control, A Brief history of Version Control Systems

Git Basics
As a young student of programming, I have only ever used Git for revision control and, until recently, only heard the existence of others as whispers in the wind. So, I thought I might go over some of the basic and intermediate commands of Git for those just discovering version control yourself or even for those who want to expand upon the foundations they have already built. *For the remainder of the article, I will be operating under the assumption the reading has basic knowledge of terminal commands. If you need a refresher, check out this MDN article.

If you have done any work with Git/GitHub at all, even on solo projects, you know about the commands listed below:

// adds file to staging area (or index)
git add <filename>
// commits file to local repository 
git commit -m “Commit Message”
// pushes commit to remote repository  
git push <remote> <branch> (or...)
git push origin main

Let us quickly define some basic concepts:
main: default development branch
origin: default upstream repository
HEAD: pointer to the current branch reference
HEAD^: parent of HEAD
HEAD~4: great-great grandparent of HEAD

Practice makes ~~perfect~~ better
When I first started using version control, I saw all these commands (and a few others) and it was intimidating, but I soon realized the thing that makes Git so great is its simplicity. On the outside looking in, it may seem daunting, but the more you use it, the more people you collaborate with, and the more projects you work on the more practice you will get (no pun intended). Before proceeding further, one thing I would like to mention is that one of the things that better helped me get a grasp on this topic was a visual reference. I strongly recommend Learn Git Branching for this very reason.

Intermediate git
Let us now touch on a few more intermediate aspects of the Git workflow. Let us say you have created an app that automates some menial tasks and a few people started using your app because, like you, they also do not find joy in menial tasks. One of your end users notices a minor bug you may have overlooked. This bug does not break the app but nonetheless needs to be fixed. You do not want to take the app offline to fix it, so what do you do? Well, you might create a branch in your local repository called ‘bug-fix’ git branch bug-fix or git checkout -b bug-fix (the latter will create the new branch move into it with one command). Now you can fix the bug while working on this branch while your end users continue using the app. After you fix the bug you would want to merge bug-fix back into your main branch git merge main or you might want to organize your commits before you merge you might consider rebasing (this is an example of interactive rebasing) git rebase -i main which just gives you a more tidy commit history (*it’s important to note that rebasing should only be done while in local repo). These are just a few commands to do with Git. If you are still interested in learning more about Git, I have taken the liberty of providing additional resources below.

Resources

Think Like (a) Git
Commit Often, Perfect Later, Publish Once: Git Best Practices
Git Best Practices: Workflow Guidelines
Learn Git Branching

What is Machine Learning?

Royce — Mon, 18 Apr 2022 13:54:51 +0000

The term “Machine Learning” was coined by Arthur Samuel (1959), a pioneer of artificial intelligence, and defined it as a “Field of study that gives computers the ability to learn without being explicitly programmed.” Machine learning is the study of computer algorithms that improve with the use of data. Machine Learning and Data Science are sometimes, inaccurately, used interchangeably but they are considered distinct fields of study, despite overlapping in some areas. Data Science conducts operations over various data sources to prove or disprove a hypothesis, and Machine Learning use various data sources to develop software that learns as it extracts meaning from the data. Machine Learning is a branch of the field of Artificial Intelligence. Machine Learning uses statistical methods to train algorithms to make predictions, or classifications, through data mining projects. These insight drive decisions made businesses and continues to grow. Machine Learning has many real-world applications, such as medical diagnosis, traffic prediction, product recommendations and others.

Machine Learning vs Deep Learning
Machine Learning and Deep Learning are both subfields of Artificial Intelligence but often the terms are used interchangeably, so let us briefly point out some of the differences between them. The way they differ is in how the algorithm learns. Deep learning automates much of the feature, or an individual measurable property, extraction process and eliminating some of the human intervention part of the process therefore allowing use of larger data sets. Machine Learning is more dependent of human intervention to determine the set of features to understand differences in data inputs. Deep Learning does not need human interaction to process the information allowing Machine Learning to scale in interesting ways.

How Machines Learn
UC Berkeley divides the Machine Learning process into three main parts:

A Decision Process: Machine Learning algorithms are used to make predictions, given a data set, which will predict patterns in the data.
An Error Function: An error function evaluates the prediction model to access the accuracy of the model.
A Model Optimization Process: If the model can better fit the data points in the training set, the weights are adjusted to improve the algorithm to better fit the training data and model estimate. This process is repeated until a certain level of accuracy is met.

Machine Learning Methods

Supervised Learning
In supervised learning, you would feed in an input-output pair and the algorithm would determine a pattern between the two. As you feed in new inputs, the algorithm would predict which output the input would belong to. The key to the accuracy, as is the case with all machine learning, is that the largest the training data the more accurate the model will be. Real-world examples of supervised learning are product recommendation (when a streaming service suggests a new movie or song you might like based on previous choices) and image classification (when someone is tagged in photos on social media and the app suggest other photos they might be in).

Unsupervised Learning
In unsupervised learning, you would feed an input (without the associated output) and as you repeat process the algorithm would group, or cluster, like values together to determine a pattern. As noted previously, the key to accurate modeling is the size of the initial data set. A real-world example would be bank fraud detection (since credit-card charges do not come with a “fraud” or “not fraud” tag fixed to them).

Reinforcement Learning
In Reinforcement learning, an input is feed to the algorithm and based on previous data, the algorithm would determine an output. The process would be refined using a “rewards/punishment” system and the program would learn from trial and error.

Machine Learning is an ever-growing field of research and continues to influence our lives as we continue to push the bounds of artificial intelligence. I, myself, am excited to learn more about it to gain more insight.

Higher-Order Functions

Royce — Fri, 18 Feb 2022 21:54:48 +0000

When I first encounter most things when learning programing, it seems like an alien language. There are unfamiliar words to learn, syntax, and initially everything is a bit confusing. The same was true when I first stumbled upon Higher-Order Functions, even more so. My goal in writing this is to possibly demystify Higher-Order Functions and come to a better understanding myself. Let’s dive right in.

First Class Functions
In JavaScript, functions are first class citizens. JavaScript is an object-oriented programming language (with functional paradigm structures as well). A function in JavaScript is an instance of an object type. Like an object, functions have properties and methods.
A first-class function is a feature in JavaScript where functions are treated like any other variable. A first-class function can be assigned as a value to a variable, can be passed as an argument into other functions, and can be returned by another function.
Consider this simple example:

1  // Function definition and invocation 
2  function add(a,b) {
3    return a + b;
4  }
5  add(5, 6) // returns 11
6
7  // Stored in a variable
8  const sum = add;
9  sum(6,7) // returns 13
10 
11 // Passed as an argument to a function
12 function functionReturner(fn){
13   return fn;
14 }
15 const total = functionReturner(sum)
16 total(5,5) // returns 10

Stored as variable
On line 2 we declare the function and call it on line 5. On line 9 we’ve created a variable called “sum” and assigned it the value of the “add” function, so that “add”, and “sum” are equal, and if we were to call “sum” with arguments it would return their sum.
One important thing to note, however, is that “add” is a function declaration and “sum” is a function expression. The reason for noting this is that function declarations are hoisted, and function expressions are not. Therefore, if you were to invoke “add” before the program reaches that line of code, it would return a value based on the arguments passed. However, “sum” would throw a reference error.

Passed as argument
Another feature of first-class functions is something known as a callback function. A callback function is passed a parameter in another function as shown on lines 11 through 16. You’ve probably seen this before in native functions like map() and filter() (which we’ll discuss later).

Returned by another Function
Something else you may have seen happen is another function returning a function. We can do this because functions are types of objects. This is particularly useful when writing larger programs that use similar functions repeatedly. You can use one function as a template to call inside another function.

Higher-Order Functions: Defined
What does any of this have to do with higher-order functions? Well, the bit about functions stored about variable isn’t particularly applicable, but functions passed as arguments and functions returned by other functions are the bread and butter of Higher-Order Functions. In fact, Higher-Order Functions ARE functions that either have another function passed in as an argument and/or return a function. In fact, Eloquent JavaScript, 3rd Edition (Haverbeke, 2018:86) defines it like this,

“Functions that operate on other functions, either by taking them as arguments or by returning them, are called higher-order functions. Since we have already seen that functions are regular values, there is nothing particularly remarkable about the fact that such functions exist. The term comes from mathematics, where the distinction between functions and other values is taken more seriously.”

Simple as that. Note: a function that doesn’t take a function as an argument and/or returns a function is called a first-order function.

Native Higher-Order Functions
JavaScript features several native higher-order functions to make programming life slightly easier. (There are also other libraries like Lodash and Underscore which offer many more). I’ll discuss two native higher-order functions that are used regularly (at least, by me).

map()
The first of the native higher-order function I’d like to discuss is the map() function (which is technically a method). The map() function, or method, is used to iterate over an array (it works on all collections, but for simplicity’s sake, we’ll stick to arrays for today), perform an action on each individual element in the original array and return a new array. It takes one argument, the callback function, which performs an action on the elements of the first array and “maps,” or designs new elements based on the callback function. Let’s look at how map() works.

let myArray = [1,2,3,4,5]
function square(number){
  return number*number;
}
let squaredArray = myArray.map(square);
console.log(squaredArray); // logs [1,4,9,16,25]

Notice we have a callback function called “square” which takes in each element in “myArray” (and has the option of taking in the index and the array as a whole), performs an action, of multiplying it to itself, and pushes the value into a new array.

filter()
Another function in the arsenal of native higher-order JavaScript functions is filter(). This method iterates over an array and creates a new array for each element of the original array that meet certain criteria. So, a callback function would look something like…

let myArray = [1,2,3,4,5]
function isEven(number) {
  return number % 2 === 0; 
}
console.log(myArray.filter(isEven)) // logs [2,4]

Conclusion
In summation, I discussed how functions are treated in JavaScript. Next, how functions can be passed in as arguments to other functions and functions can be returned by functions, as well. We learned this is the very definition of a Higher-Order function. Finally, we looked at two commonly used built-in Higher-Order functions featured by JavaScript.