DEV Community: b.chau504

Going Down the Gopher Hole. Intro to Go

b.chau504 — Mon, 29 Aug 2022 04:31:00 +0000

As developers, when we are debugging, we always end up turning to Google for answers. To no surprise, it's the world's most used search engine. Google is also part of FAANG(Facebook, Amazon, Apple, Netflix, Google), some of the world's largest, most well-known tech companies. Many individuals that start their journey as a software developer aspire to work for one of these big tech companies, like Google.

So what does it take to work for a company like Google? Some of the main programming languages used within Google include C++, Python, Java, and Javascript. You may have heard of some of these well-known, general languages, but there is a language that Google uses in several of their internal projects that include Chrome, App Engine, Earth, and Youtube. This language is called Go(or GoLang for better search search results). It was developed at Google, so learning Go will definitely give you an advantage in the interview process.

Go is an open-sourced, compiled, and statically typed programming language. It was designed to improve the programming productivity within Google and allow developers to create dependable or concurrent applications. Because it compiles quickly, many programmers feel that they can get a lot more done.

Go's simplicity and readability are among the reasons it quickly gained popularity and became many developer's first choice. It is simple to learn, especially if you have prior experience with another programming language.

Getting Started with Go

Install

To get started using Go, we would need to download and install it.

Once installed, verify that Go has been installed by opening your terminal and run the following command:

$ go version

Note: For the changes to take effect, you may need to restart your terminal.

If the command prints the installed version of Go, you can move on to the next step.

Setup

cd into the directory that you'd like to create your go project.

cd %PATH%

Create a directory for you Go source code

mkdir gobasics
cd gobasics

When your code imports packages from other modules, you manage those dependencies in your own module. A go.mod file defines that module, which tracks the modules that offer those packages. That go.mod file is kept with your code and in your source code repository.

Run the go mod init command and specify the name of the module your code will be in to enable dependency tracking.

In development, the module path is usually the repository location where your source code is stored. The module path, for instance, could be github.com/mymodule. If you intend to make it available to others, the module path must point to a location where Go tools can download it.

We will be using example/gobasics.

$ go mod init example/gobasics
go: creating new go.mod: module example/hello

To open your text editor, in the gobasics directory, run the command:

$ code .

In your text editor terminal create a file to begin writing your code.

$ touch gobasics.go

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

The above code is a basic setup.

We start by declaring main package to create a standalone executable. (A package is a method of grouping functions that is made up of all the files in the same directory)
Afterward, we would import the fmt package, which has tools for formatting text, like printing to the console. When you installed Go, you received this package as one of the standard library packages.
Finally, create a main function that will print a message to the console. When you launch the main package, a main function is executed by default.

Let's give it a try. Run the following command in your terminal:

$ go run .

Basic Syntax

Let's get into some of the basic syntax of Go and see how easy it is to learn.

Printing

package main

import "fmt"

func main() {
  var i, j string = "Super", "man"

  fmt.Print(i)
  fmt.Print(j)

}

The Print() function prints its arguments with their default format, so this will output Superman in one line.

package main

import "fmt"

func main() {
  var i, j string = "Super", "man"

  fmt.Print(i, "\n") // => Super
  fmt.Print(j, "\n") // => man
}

Use \n if you want to print the arguments on separate lines.

fmt.Print(i, "\n", j)

It is also possible to print many variables with a single call to Print().

fmt.Print(i, " ", j)

Use " " to separate string arguments.

package main

import "fmt"

func main() {
  var i,j = 10,20

  fmt.Print(i,j)
}

If neither argument is a string, Print() places a space between the parameters.

package main

import "fmt"

func main() {
  var i,j string = "Super","man"

  fmt.Println(i,j) // => Super man
}

Then there is Println(), which is a derivative of Print() that adds whitespace between the arguments and a new line at the end of the output.

Variables

package main

import "fmt"

func main() {
  var favFood string = "sushi"
  x := 4

  fmt.Print(favFood) // => sushi
  fmt.Print(x) // => 4
}

Variables are declared using the var keyword, followed by the variable name and type. You must always specify either type or value or both.

Using the := sign, the type is inferred from the value, meaning the type is determined by the value by the compiler.
When using the := sign, you must always assign a value to it.

Unlike the var keyword, := can only be used inside functions and variable declaration and value assignment has to be done in the same line.

package main
import "fmt"

func main() {
  var a string
  var b int
  var c bool

  fmt.Println(a) // => 
  fmt.Println(b) // => 0
  fmt.Println(c) // => false
}

A variable's value will be set to the type's default value if it is declared without an initial value.

package main

import "fmt"

func main() {
  var a, b int = 6, 2

  fmt.Println(a) // => 6
  fmt.Println(b) // => 2

  c, d := 4, "Ever"

  fmt.Println(c) // => 4
  fmt.Println(d) // => Ever
}

Several variables can be declared in a single line. When using the type keyword, you can only declare one type of variable per line. Otherwise, you can declare different types of variables in the same line.

package main
import ("fmt")

func main() {
   var (
     a int
     b int = 0
     c string = "seven"
   )

  fmt.Println(a) // => 0
  fmt.Println(b) // => 0
  fmt.Println(c) // => seven
}

For better readability, several variable declarations can be gathered within a block.

Arrays

package main

import "fmt"

func main() {
  var arr1 = [4]int{1,2,3,4}
  arr2 := [5]int{5,6,7,8,9}
  var arr3 = [...]string{"Pomeranian","Husky","Shiba","German Shepherd"}

  fmt.Println(arr1[2]) // => 3
  fmt.Println(arr2[0]) // => 5
  fmt.Println(arr3[1]) // => Husky
}

When declaring an array you must specify the length of the array by number like arr1 and arr2 or its inferred like arr3. A specific array element can be accessed by using the index number.

Exploring Swift

b.chau504 — Wed, 10 Aug 2022 05:45:00 +0000

With more people owning mobile phones than toilets, the thought of mobile app development seemed like a good idea. So I wanted to explore it a little more.

There are two types of mobile app development that you can get into, native and cross-platform. Selecting between the two is one of the most important choices to make when getting into mobile app development.

A brief description of the two:

Cross-platform development is as it sounds; it refers to the process of developing an app that functions across many platforms. This is accomplished through the use of technologies such as React Native, Xamarin, and Flutter, and the resulting apps can be deployed on both Android and iOS.

Native App development on the other hand, involves building a mobile app entirely for a single platform. It is built using programming languages and tools that are exclusive to one platform. For instance, you can create native Android apps using Java and Kotlin and native iOS apps using Swift and Objective-C.

I wanted to delve into Swift a bit further because it is one of the most in-demand and popular languages employers and companies seek. It is also said to be one of the more beginner friendly programming languages.

Where did Swift come from?

Objective-C, Apple's previous programming language, has been mostly untouched since the early 1980s and lacked current language capabilities. Swift, which was first introduced in 2014 at Apple's Worldwide Developers Conference(WWDC), was created as a replacement. It builds on Objective-C concepts, but modernizes them to include cleaner syntax and simpler readability, maintainability, and safety to prevent crashes.

Swift outperformed Objective-C in a few areas, including type safety, security, and greater on-hardware performance. Swift is more than 8.4 times quicker than Python and more than 2.6 times faster than Objective-C.

Swift is built on modern methods found in other modern programming languages such as JavaScript. For those who are coming from Javascript like me, here are some syntax differences and similarities between Javascript and Swift.

Javascript:

console.log("Hello World");

Swift:

print("Hello World");

The var expression is used to declare a new variable with a value in both JavaScript and Swift.

var similar = "JS and Swift";

Constants in Swift can also be defined as:

let favFood = "sushi";

All variables used in JavaScript are either strings, functions, or objects because it is entirely a dynamically typed language, however in Swift, the language is completely static type based, thus you have to explicitly state the types. For instance, in Swift, you would need to write it like this to separate the definition and declaration:

var dogName: String;
dogName = "Bumi";

Template literals
Javascript:

var firstName = "Neil", middleName = "Patrick", lastName = "Harris";
console.log(`Full name is ${firstName} ${middleName} ${lastName}`);

Swift:

var firstName = "Neil", middleName = "Patrick", lastName = "Harris";
console.log("Full name is \(firstName) \(middleName) \(lastName)")

Despite the fact that Swift seems to have so many fans, the language is still far from ideal. When it comes to transitioning to the new language, many developers and company owners are very cautious. This is appropriate for a number of reasons.

The language is still in its early stages. When compared to Objective C, which has been around since the 1980s, Swift was first presented to the public in 2014. Although it may seem like a long time ago, Swift is actually only 8 years old. The most recent upgrade improved ABI stability across Apple's platforms, backward compatibility with Swift versions, and documentation. Those are significant moves in the direction of making Swift a more sophisticated language.

However, concurrently, continuous updates and modifications can lead developers to question whether their project can even be built, let alone whether the code they are writing now will work with earlier versions tomorrow.

Compared to any other open source language, the Swift community is still much smaller, despite its rapid growth. Only 5.1 percent of the 83,053 respondents to the most recent StackOverflow Developer Survey reported using Swift. Therefore, if you want to use Swift for your next project, you could have difficulties finding developers that have sufficient Swift experience.

Swift is used for more than just creating apps for Apple products. It was intended to be a general-purpose language. Swift has been compatible with Linux since version 2.2 was released in 2016 for the operating system. Version 5.3 of Swift was published in 2020, making it usable on Windows. It can be used on the top three operating systems as a cross-platform programming language.

This indicates that Swift is being used to build online services and even web apps, and that developers may discover further uses for it in the future. This gives me pleasure to see the growth of this programming language and hope to work with it in the future.

Should I Learn PostgreSQL?

b.chau504 — Mon, 01 Aug 2022 03:48:00 +0000

I'm currently at a point in my coding journey where I am nearly finished completing my first coding bootcamp. Job hunt will be the next step to take so that I can finally land that dream job that I and so many others desired.

But first, building a strong resume that appeal to employers is crucial. It can be challenging drafting a resume as an entry-level software engineer. Upon writing out my current technical skills, I became curious to see what technical skills employers and companies would like to see in candidates. I found that a consistently solid understanding of databases is essential for software engineers because they are an integral component of software and application development. Which makes sense, because the world today simply cannot function without data.

You will most likely expect to encounter database administration functions such as how to create, update, store, modify, and insert information. In the case that you are working with an organization's records or improving its security will need you to be familiar with their database.

The industry standard for managing databases is SQL. SQL is known as a relational database management system (RDBMS), which means it saves data in rows and columns like a spreadsheet, as opposed to non-relational databases, which do not. Non-relational databases use a storage model that is best adapted for the type of data it is storing.

There are several relation databases that use and support SQL querying; PostgreSQL being one of them.

Why learn PostgreSQL?

Well, what exactly is PostgreSQL? Let's define it in more detail.

PostgreSQL, commonly goes by the name Postgres, is an open-source and free to use RDBMS. (Who doesn't like free, right?)
An extremely robust database that has been developed by the open-source community over the course of more than 30 years.
It is an advanced version of SQL.
Runs on all major operating systems(Linux, macOS, Windows)
ACID-compliant since 2001.
Supports JSON(non-relational) querying as well.
Many web applications, as well as mobile and analytics applications, rely on it as their primary database.

Now that we have a general idea of what Postgres is, let's look at why learning how to utilize this database can be advantageous.

Given that it is so similar to SQL standards, it makes it a great option for individuals who are new to SQL.

Some of the largest and most well-known companies in the industry includes Postgres as part of their tech stack. The list includes companies like Apple, IMDB, Instagram, Reddit, Skype, Spotify, Twitch and NASA. db-engines.com has calculated the popularity of DBMSs over the years and has declared Postgres as the DBMS of the Year in 2017, 2018, and 2020. Making it the first system to win the title three times. According to a survey conducted by stackoverflow.com, Postgres is currently the second most popular database system used by actual professional developers. So adding it to your array of technical skills will surely offer more job opportunities.

Many features in Postgres are designed to support developers in creating applications, administrators in protecting data integrity and constructing fault-tolerant systems, and you in managing your data regardless of the size of the dataset. Postgres is quite extendable. You can, for instance, create custom functions, define your own data types, and even write code in a variety of programming languages without having to recompile your database. It aims to comply to the SQL standard if such conformity does not conflict with conventional features or lead to poor architecture choices. Despite occasionally having somewhat different syntax or functionality, many of the features required by the SQL standard are supported. Continued progress in this direction can be expected. As of the September 2021 version 14 release, Postgres complies with at least 170 of the 179 requirements for SQL:2016 Core conformance.

The well-known PostGIS geospatial database extender is only one of the many add-ons for Postgres. It provides support for geographic objects, allowing location queries to be performed in SQL. In addition to basic location awareness, PostGIS provides several capabilities not available in competing spatial databases such as Oracle Locator/Spatial and SQL Server.

After doing some research on Postgres, it has demonstrated to me that it deserves and will have a position in my tech stack. Following market trends is the plan of attack right now and Postgres is one of the most popular and widely used database management systems in the world. With it being regularly improved by the open source community, I'll have plenty to keep me occupied since I enjoy learning new concepts and technology. I hope this helps you decide if learning Postgres is worth your time.

Type of Apps

b.chau504 — Sun, 26 Jun 2022 01:38:35 +0000

Different Types of Apps

A typical user might not be able to distinguish a website, web app or native app on first sight. As long as they get the results for what they are searching for, the type of app doesn't really matter. As developers though, it's important that we know the difference between the various types of apps.

Building the right app for users to enjoy is something we as developers should strive for. Making an app that is user friendly is a sure way to get many people to start using your app. There are different types of apps and each have their own purpose, but which is more preferred by users?

It's crucial to understand the distinctions between websites and web applications since they can often be mistaken for one another due to their similarities.

Websites vs Web Apps

Websites

Websites are a collection of linked web pages that may consist of text, images, audio, video, and other content. It can be linked to one page, two pages, or numerous amounts of pages. Through a browser like Chrome or Firefox, you are able to view them. A website can be created using only HTML and CSS, but Javascript may be used to give it more dynamic features. Typically, websites are static in nature, meaning the content is organized in pages and they are not constantly updated. Often times, they are generally referred to as read-only sites. Archive websites, blogs, and community sites are just some examples of the type of static websites out there. A website's main intent is to facilitate user navigation and obtain information that is pertinent to their needs.

Web Apps

Web apps, unlike webpages, require authentication. To present information, the web application utilizes both server-side and client-side scripts. It requires the use of a server to manage user requests. The visual difference between websites and web apps are that they are particularly dynamic and responsive. Every user sees a new set of data each time. These features make usability smooth and more engaging than a typical website.

Like websites, web apps are built using HTML, CSS, and Javascript. It also makes use of a database and a few other computer languages, including Ruby, PHP, and frameworks like Django, Angular, React, and Ruby on Rails.

Some examples of web apps:

Native Apps

Native apps are software programs that are designed to use on a specific device or platform like IOS or Android and Mac or Windows. The great thing about a native app is it can be installed directly onto the device, allowing users to still use it without internet connectivity, in most cases. Native apps are also capable of accessing a devices features, such as push notifications.

Swift is a powerful and user-friendly programming language designed by Apple to develop iOS and MacOS apps. Other languages are available to use when building native apps like, Objective-C and C#. Android, on the other hand, uses Java, Kotlin, and Python to build their apps.

Progressive Web Apps

PWAs are web applications created using a shared set of specific technology and practices that enable them to use both web and native app features. Web applications, for example, are more discoverable than native apps; visiting a website is much more quicker and easier than installing an app, and you can conveniently share web apps by simply sending a link. Native apps, on the other hand, are properly designed to work with the operating system and thus provide a more smooth user experience. We recently discussed how native apps are installed so that they may also be used offline, and users prefer to access their favorite apps simply tapping their icons rather than using a browser. Progressive web applications make it possible to create web apps that can use features that make web apps and native apps so great.

From the outside, it's difficult to tell whether a web app is progressive or not. Like web apps, PWAs use HTML, CSS, and Javascript. When an app satisfies specific standards or incorporates a set of provided features, it is deemed a PWA: it operates offline, is installable, is easy to synchronize, can send push notifications, and so on. Lighthouse, for example, is a tool that measures how complete (as a percentage) a web app is.

One thing to note when developing an app, is the cost of development. A progressive web app is less expensive to produce than a native app. For the native app, you will need to learn the language and create a version for each platform. This implies you'll need at least two versions for iOS and Android, as well as the resources to keep each one up to date. This involves a serious amount of time and money, depending on the app's intent and complexity.

It takes less time to create and update a progressive web app. You can use a single codebase for several platforms in addition to the two most widely used ones. With the use of tools like Google Lighthouse, you can modify your existing website rather than creating an app from start. With responsive design, you only need one version of the app, and it will operate the same way across all platforms.

The Importance of SEO to Developers

b.chau504 — Sun, 19 Jun 2022 05:39:32 +0000

What's beyond the first search page?

Have you ever searched something on google and gotten to the tenth page before finding what you needed? No? Maybe the fifth? Or the third? I wouldn't be surprised if most of the time you find what you are looking for right on the first search page. According to a 2014 study conducted by Moz, an SEO and data management software site, 71.33 percent of Google search traffic never goes beyond the first page of results, with the number rising to 92 percent in recent years. Second-page results are a distant second, accounting for only around 6% of all website clicks.

What is SEO?

SEO is the abbreviation for "search engine optimization." In layman's terms, it's the process of refining your website to make it more visible when people look for products or services relevant to your business.

An SEO-friendly site, at its most basic level, allows a search engine to browse and read pages throughout the site. The first step to guarantee your exposure in search engine result pages is to ensure that a search engine can simply crawl and understand your material. We can do that by customizing our HTML and CSS.

In every web developer's journey, they will come across some HTML and CSS. It's vital for developers to have some basic knowledge of it when building a website from the ground up. Knowing HTML tags and CSS properties is one thing but knowing how to use them to build more traffic to your site is another.

Here are different ways to utilize HTML:

Title Tag

<title>Title Tag</title>

The most essential HTML signal that search engines use to identify what a site is about is the title. It's critical that your titles are distinctive and descriptive in order for users and search engines to understand what your pages are about. In most cases, the clickable link in a search result is the title tag. Search engines will only display the first 50-60 characters of your title, so keep it brief, but avoid one- or two-word titles. It should also accurately represent the content of your page and include the keywords you want to rank for.

Anchor Tag

<a href="http://www.example.com">Anchor Tag Text</a>

Internal links should be prioritized while developing a website to help search engines understand the site structure and to make the browsing process easier for users. Search engines will have trouble crawling and indexing web pages that are not linked to one another, and the web pages will not display on the search engine results page.

Heading Tag

<header><h1>Heading Tag</h1></header>

Headings are a means to structure and define key sections of your content in a hierarchical manner. A headline is often seen at the top of a page. The content on this page is divided into several sections by a headline and many subheadings. H2 tags, the next "level" down from H1 tags, are being used for those sub-headings. Clear, meaningful headers help search engines understand pages and make your content more user-friendly.

Meta Description Tag

<head>
<meta name="description" content="This is an example of a
meta description. This will often show up in search results.">
</head>

The meta description tag is typically inside the head tag, not to be confused with the header tag that we previously explored. It is an HTML element that allows you to specify how your web pages should be represented in search results. In the search results, descriptions will display below the headlines. It's more of a "success" factor than a ranking factor. A well-written description can persuade consumers to choose your site over others on the search page.

<img src="http://www.ExampleImageTagAddress.com/image-tag.png" alt="Image Tag">

Alt text (alternative text) is used in HTML code to explain in text, the appearance and purpose of an image on a website. It is sometimes known as "alt attributes," "alt descriptions," or "alt tags." In the event that an image fails to load on a user's screen, the alt text will appear in its place. Although it is not necessary for terms of being indexed and ranked, it can help visually impaired users who are using screen readers. An alt attribute will be read aloud to them to help them interpret an on-page image.

CSS:

Having a responsive website is a requirement in today's world of the web. With smartphone users increasing rapidly, developers must create a website that is suitable for mobile phones, as well as desktops, tablets, and other devices. Search engines favor mobile-friendly websites since they match SEO standards.

Media Query

Depending on a specified set of conditions regarding the user's device, browser, or system settings, media queries can change the appearance (and possibly functionality) of a website or app.

Freelance web developers are often web designers and web developers. So it is necessary for them to have knowledge of SEO. It can look good when advertising yourself to have both skills.

If you are not a freelancer or have not decided to become one, it can still be a very important skill to learn. Any small company or business would be pleased to work with someone who does both SEO and web development.

Web developers, especially those who are new to the field, must understand the significance of SEO in web development. It can enhance your résumé and give you more job opportunities.

How does AWS Deployment work?

b.chau504 — Sun, 12 Jun 2022 22:23:45 +0000

What is AWS?

Are you considering deploying your application with Amazon Web Services(commonly known as AWS)? Not entirely sure what deployment service to use for your code? Maybe you're just curious about how AWS works, or if their services would be something you want to use. Well there's a reason more than 45 percent of the world is using AWS today. It is widely used by many small businesses, large-scale companies and government agencies. AWS has a variety of services from data centers to compute services to cloud platforms, just to name a few. Actually, AWS has over 200 services. Some of the few AWS services that we'll be exploring to deploy your next application:

Deployment before AWS

Let's take it back once more to see how developers would deploy their code. Before AWS dominated the cloud computing industry, developers would manually log into the server and run deployment scripts. The problem with this was that it was extremely risky. Businesses would have to plan for and acquire servers and IT infrastructure weeks or months ahead of time.

Amazon EC2

Amazon EC2 makes it easy for you to obtain virtual servers(also known as compute instances in the cloud) quickly. AWS gives you the freedom to launch as many or as few virtual servers as you need, configure security and networking, and manage storage.

Mutable Infrastructure

Manually connecting to a single Amazon EC2 instance to deploy new code has certain drawbacks. There's a possibility something may go wrong with your code or scripts, causing all users to be affected. If you test your code on a development server, there's always the possibility that it won't work on the production server.
This is referred to as mutable infrastructure.

Assume someone logged in, made a change, and then failed to update the development server. Your deployment in one mutable server may respond differently in another mutable server.

Immutable Infrastructure

With immutable infrastructure, there are no changes taking place on the production server. Which allows us to implement control changes so that our running code updates in a predictable manner. The running code only updates when it is completely replaced with a new instance that contains all the necessary changes.

Consider the example above.

With two instances, one instance can be for deployment and while the other one keeps serving the traffic. What happens when an instance fails or has an increase in traffic? AWS has a service to solve that problem also.

AWS Auto Scaling

Auto scaling is an effective method of ensuring the availability and predictable performance of many instances that serve traffic. As the demand on your instances varies, Amazon EC2 Auto Scaling allows you to dynamically raise or reduce the number of instances. When an instance fails or there is a spike in traffic, auto scaling automatically creates new instances immediately by utilizing an AMI (Amazon Machine Image). The operating system and all software packages required to run the application are included in AMIs.

Amazon Elastic Load Balancing(Amazon ELB)

Your incoming application traffic is dynamically distributed across all of your running EC2 instances using Elastic Load Balancing. Elastic Load Balancing distributes incoming requests across several servers, ensuring that no one server is congested.

Attach the load balancer to your Auto Scaling group if you want to use Elastic Load Balancing with it. This connects your Auto Scaling group to the load balancer, which serves as a central point of contact for any and all incoming web traffic.

Individual EC2 instances do not need to be registered with the load balancer while using Elastic Load Balancing with your Auto Scaling group. The load balancer automatically registers instances that are launched by your Auto Scaling group. Similarly, instances removed from your Auto Scaling group get deregistered from the load balancer automatically.

The Ease of Deploying with AWS CodeDeploy

AWS CodeDeploy makes it simple to automate code deployments while still maintaining application uptime. Its automated deployment capabilities make it an excellent solution for updating application and promptly release new features without the risk of errors.

Conclusion

Every coder, programmer, developer(call it what you will) will deploy their application to a server at some point throughout their career. It doesn't matter if it's a large server or a small server. It might be one or a hundred servers. Whatever your requirements are, you'll most likely want to have servers as quickly and efficiently as possible.

Understanding a bit about AWS can help you advance in your profession and find your next job. You can pursue a variety of certifications and positions that Amazon offers. It's perfectly fine if you're not interested in working for Amazon. AWS skills, on the other hand, are in high demand for almost any developer position. So, are you planning to use any of Amazon's online services?

Factory Functions vs Constructors

b.chau504 — Sun, 24 Apr 2022 22:39:22 +0000

To grasp the concept of factory functions and constructors, you must first understand functions and objects.

If you're creating numerous amounts of objects with similar properties and functionality, it can be tedious and repetitive. We want to keep in mind the principle of keeping our code D.R.Y., which stands for "Don't Repeat Yourself". There are function patterns that can help us write shorter, cleaner, more efficient code. Factory functions and constructor functions can do just that, but which one should you use? Let's dive a little deeper into what factory functions and constructors are, what they can and can't do, and the similarities and the differences.

What are factory functions?

Factory functions can be thought of as an actual factory that takes in raw materials and produces numerous products promptly. Factory functions, on the other hand, take in specific inputs and uses those inputs to create a new object. So, how can this actually be useful to us? We can simply create each object individually, but that might take some time. If you are creating objects with the same properties and different values, then creating one factory function can make this process quicker.

const car1 = {
    make: 'Toyota',
    model: 'Tacoma',
    year: 2018,
    fuelType: 'gas', 
    bodyType: 'mid-size pick-up truck',
    getFullName() {
        return `${this.year} ${this.make} ${this.model}`;
    }
}

console.log(car1.getFullName()); // => 2018 Toyota Tacoma

In the example above, we create an object describing a specific car. Now let's make a similar object to this one.

const car2 = {
    make: 'Tesla', 
    model: 'Model S',
    year: 2018,
    fuelType: 'electric',
    bodyType: 'sedan',
    getFullName() {
        return `${this.year} ${this.make} ${this.model}`;
    }
}

console.log(car2.getFullName()); // => 2018 Tesla Model S

Now, I can continue creating objects of more cars, but who has time for that, right? Let's see what this would look like as a factory function.

function createCar (make, model, year, fuelType, bodyType) {
    return {
        make: make, 
        model: model, 
        year: year, 
        fuelType: fuelType, 
        bodyType: bodyType,
        getFullName() {
            return `${year} ${make} ${model}`;
        }
    }
}

We now have a factory function that creates new objects for us. Now, all we have to do is pass in data and let the factory function do its thing.

function createCar (make, model, year, fuelType, bodyType) {
    return {
        make: make, 
        model: model, 
        year: year, 
        fuelType: fuelType, 
        bodyType: bodyType,
        getFullName() {
            return `${year} ${make} ${model}`;
        }
    }
}

const car1 = createCar('Toyota', 'Tacoma', 2018, 'gas', 'mid-size pick-up truck');
const car2 = createCar('Tesla', 'Model S', 2018, 'electric', 'sedan');

console.log(car1.getFullName()); // => 2018 Toyota Tacoma
console.log(car2.getFullName()); // => 2018 Tesla Model S

You may build any number of objects by utilizing the factory function instead of repeating code.

What are constructors?

A constructor function is another javascript pattern, that is very similar to factory functions. Though, unlike factory functions, constructor functions do not actually return an object. To create different objects with the same properties, we would need to use the keyword "new" and the keyword "this". With that being said, let's see how constructor functions work visually.

function Car(make, model, year, fuelType, bodyType) {
    this.make = make
    this.model = model 
    this.year = year
    this.fuelType = fuelType
    this.bodyType = bodyType
    this.getFullName = () => {
        return `${this.year} ${this.make} ${this.model}`;
    }
}

In the example above, the constructor function looks a lot like a factory function, except for the use of the keyword "this"."this" refers to the constructor function that created the instance object. In other words, "this" has no value in a constructor function. You can think of it as a stand-in for the new object.

function Car(make, model, year, fuelType, bodyType) {
    this.make = make
    this.model = model 
    this.year = year
    this.fuelType = fuelType
    this.bodyType = bodyType
    this.getFullName = () => {
        return `${this.year} ${this.make} ${this.model}`;
    }
}

const car1 = new car('Toyota', 'Tacoma', 2018, 'gas', 'mid-size pick-up truck');
const car2 = new car('Tesla', 'Model S', 2018, 'electric', 'sedan');

console.log(car1.getFullName()); // => 2018 Toyota Tacoma
console.log(car2.getFullName()); // => 2018 Tesla Model S

To create objects using constructor functions, we use another keyword, "new". When you use the term "new" in front of a function call, javascript does two things for us automatically:

Inside the function, creates an empty object with the name "this".
Returns the object "this" to the statement that called the function initially.

function Car(make, model, year, fuelType, bodyType) {
    // const this = {};
    this.make = make
    this.model = model 
    this.year = year
    this.fuelType = fuelType
    this.bodyType = bodyType
    this.getFullName = () => {
        return `${this.year} ${this.make} ${this.model}`;
    }
    // return this;
}

const car1 = new car('Toyota', 'Tacoma', 2018, 'gas', 'mid-size pick-up truck');
const car2 = new car('Tesla', 'Model S', 2018, 'electric', 'sedan');
console.log(car1.getFullName()); // => 2018 Toyota Tacoma
console.log(car2.getFullName()); // => 2018 Tesla Model S

Inheritance

Inheritance plays a big part in how factory functions and constructor functions are different.

function createCar (make, model, year, fuelType, bodyType) {
    return {
        make: make, 
        model: model, 
        year: year, 
        fuelType: fuelType, 
        bodyType: bodyType,
        getFullName() {
            return `${year} ${make} ${model}`;
        }
    }
}

const car1 = createCar('Toyota', 'Tacoma', 2018, 'gas', 'mid-size pick-up truck');
const car2 = createCar('Tesla', 'Model S', 2018, 'electric', 'sedan'); 

car1.getFullName = function() {
    return `My ${fuelType} ${bodyType} is a ${year} ${make} ${model}`;
}

console.log(car1.getFullName()); // => My gas mid-size pick-up truck is a 2018 Toyota Tacoma
console.log(car2.getFullName()); // => 2018 Tesla Model S

Let's refer back to the first example of the factory function. What if we wanted to redeclare car1.getFullName()? Well, car1.getFullName() and car2.getFullName() are not the same function in memory. Each object gets its own copy of the function. Meaning, that when the function creates an object and returns it, it copies the properties and values and attaches them to every object calling the function.

function car(make, model, year, fuelType, bodyType) {
    // const this = {};
    this.make = make
    this.model = model 
    this.year = year
    this.fuelType = fuelType
    this.bodyType = bodyType
    this.getFullName = () => {
        return `${this.year} ${this.make} ${this.model}`;
    }
    // return this;
}

const car1 = new car('Toyota', 'Tacoma', 2018, 'gas', 'mid-size pick-up truck');
const car2 = new car('Tesla', 'Model S', 2018, 'electric', 'sedan');

console.log(car1); // => car {make: 'Toyota', model: 'Tacoma' , etc.}

Now, let's take a look at our constructor function above. When a constructor is made, it comes with its own prototype. When we create a new car object using the "new" keyword, it creates an instance of the car type. In other words, car1's prototype is of type "car". Now, car1 is inheriting from the car constructor. This allows us to add properties to the prototype car.

Car.prototype.sentence = function() {
    return `My ${this.fuelType} ${this.bodyType} is a ${this.year} ${this.make} ${this.model}`;
}

console.log(car1); // => Car {
//   make: 'Toyota',
//   model: 'Tacoma',
//   year: 2018,
//   fuelType: 'gas',
//   bodyType: 'mid-size pick-up truck',
//   getFullName: [Function (anonymous)]
// }

Notice that the sentence function isn't directly added to the car constructor itself.

console.log(Car.prototype); // => { sentence: [Function (anonymous)] }

But when we check its prototype, there it is! Now we're able to access the newly added function.

console.log(car1.sentence()); // => My gas mid-size pick-up truck is a 2018 Toyota Tacoma
console.log(car2.sentence()); // => My electric sedan is a 2018 Tesla Model S

Now that we know how each operation works, the question is: Which one should we use? They can both get you the same result. Constructors are great when you want to add or remove a property from every object inheriting from the constructor. However, factory functions can be more straightforward to understand, because, at the end of the day, it's just a function. For factory functions, we don't have to involve the keyword "new". It can be more flexible, with the power of closure. With that, we can accomplish something called "data privacy". Let's look at one more example explaining how this works.

function createCar(make, model, year) {
    return {
        getFullName() {
            return `${year} ${make} ${model}`;
        }
    }
}

const car1 = createCar('Toyota', 'Tacoma', 2018); 

console.log(car1.getFullName()); // => 2018 Toyota Tacoma
console.log(car1.make); // => undefined
console.log(car1); // => { getFullName: [Function: getFullName] }

car1.make is hidden and it cannot be reached or found in the prototype. This makes it more difficult to accidentally create a bug somewhere in your code.

Conclusion

All in all, the great thing about writing your own code is nothing is necessarily wrong. There is a good practice of keeping our code clean and short. Use factory functions and constructor functions where you think it would be best for your case.

Sources