DEV Community: Quinn Lashinsky

Pausing Rust By Example

Quinn Lashinsky — Mon, 29 Mar 2021 15:36:42 +0000

I want to thank everyone who has been kind enough to follow this series on learning Rust through Rust by Example.

The amount of time I want to put into making a quality blog series is at odds with my main goal of getting better at HTML, CSS, and Javascript. I need to dedicate more time to those languages instead of learning a new one.

I look forward to coming back to this series in the future when I have more time!

Making Change Algorithm

Quinn Lashinsky — Thu, 25 Mar 2021 17:04:07 +0000

This past week I did a coding challenge that I actually enjoyed. The problem wasn't ridiculously abstract or one I would never solve if I were hired as a Junior Engineer. Below I'm gonna give the problem, show my pseudo-code, and then solve it. This may not be the best solution, but it works. I'd love to see other solutions. Write or link to your solution in the comments and feel free to add possible edge cases I may have missed.

The Problem

Given a payment array of US monetary denominations (i.e. 10.00 or .05), and the price of an item, calculate the least amount of coins a person should receive after paying for their item. If they do not input enough money, return their money in the least amount of coins possible. The coins given back should be formatted like this, [pennies, nickels, dimes, quarters].

For example:

// Can buy

// input
const price = 1.25
const payment = [.25, .50, .10, 1.00]

// output
makeChange(1.25, [.25, .50, .10, 1.00])
// [0, 1, 1, 0]

// 0 Pennies
// 1 Nickel
// 1 Dime
// 0 Quarters

// Cannot buy

// input 
const price = 1.50
const payment = [1.00, .10]

// output
makeChange(1.50, [1.00, .10])
// [0, 0, 1, 4]

// 0 Pennies
// 0 Nickels
// 1 Dime
// 4 Quarters

My Pseudo-Code

Here is the initial pseudo-code I came up with:

Convert the price to cents
Convert each value in the payment array to cents
If paymentInCents equals priceInCents, return [0,0,0,0]
Determine how much change I owe (If I paid less than the priceInCents, or more than the priceInCents)
1. If paymentInCents is greater than priceInCents, buyer is owed paymentInCents minus priceInCents
2. If paymentInCents is less than priceInCents , buyer is owed paymentInCents
Create a changeArray to keep track of the amount of each denomination I am returning as change.
Calculate change owed to our buyer for each denomination (quarters, dimes, nickels, pennies) in descending order. Put those values in their corresponding position ([pennies, nickels, dimes, quarters]). After we complete this process, the amount of change owed should be 0
Return changeArray, which is the amount of each denomination owed to the buyer.

My Solution

function makeChange(price, payment){

    const priceInCents = price * 100

    const paymentInCents = payment.reduce((acc, curr) => {
        return acc += curr * 100
    }, 0)

    if (priceInCents === paymentInCents){
        return [0, 0, 0, 0]
    }

    let changeOwed = priceInCents > paymentInCents 
        ? 
            paymentInCents 
        : 
            (paymentInCents - priceInCents)

    return calculateChangeOwed(changeOwed)
}

function calculateChangeOwed(changeOwed){
    let currentChangeOwed = changeOwed
    const changeArray = []

    const amountOfQuarters = Math.floor(currentChangeOwed / 25)
    currentChangeOwed -= (amountOfQuarters * 25)
    changeArray.unshift(amountOfQuarters)

    const amountOfDimes = Math.floor(currentChangeOwed / 10)
    currentChangeOwed -= (amountOfDimes * 10)
    changeArray.unshift(amountOfDimes)

    const amountOfNickels = Math.floor(currentChangeOwed / 5)
    currentChangeOwed -= (amountOfNickels * 5)
    changeArray.unshift(amountOfNickels)

    const amountOfPennies = Math.floor(currentChangeOwed / 1)
    currentChangeOwed -= (amountOfPennies * 1)
    changeArray.unshift(amountOfPennies)

    return changeArray
}

Some Explanations

Why Did I Convert All Monetary Values to Cents?

In Javascript mathematical operations with floating point numbers may lack numeric precision and may not give us the results we expect. For example:

console.log(40.90 * 3)
// 122.69999999999999

The output should be 122.7, right? Unfortunately, we can't expect Javascript to give us perfect representations of floats. Integers on the other hand can be represented perfectly, and converting all monetary values to cents will help us avoid floating point number issues.

Is This Code D.R.Y?

I repeat the same code 4 times while calculating how much of each currency is owed to the buyer.

// ... code ...

const amountOfQuarters = Math.floor(currentChangeOwed / 25)
    currentChangeOwed -= (amountOfQuarters * 25)
    changeArray.unshift(amountOfQuarters)

    const amountOfDimes = Math.floor(currentChangeOwed / 10)
    currentChangeOwed -= (amountOfDimes * 10)
    changeArray.unshift(amountOfDimes)

    const amountOfNickels = Math.floor(currentChangeOwed / 5)
    currentChangeOwed -= (amountOfNickels * 5)
    changeArray.unshift(amountOfNickels)

    const amountOfPennies = Math.floor(currentChangeOwed / 1)
    currentChangeOwed -= (amountOfPennies * 1)
    changeArray.unshift(amountOfPennies)

// ... more code ...

And I think it's entirely possible to clean this code up and make it better.

With `reduce`

If I create an array of each denomination I could possibly return in descending order I can use the reduce function to create an array of amount of each denomination owed to the buyer.

let currentChangeOwed = 155
let denominationArray = [25, 10, 5, 1]

denominationArray.reduce((acc, curr) => {
  const amountOfDenomination = Math.floor(currentChangeOwed / curr)
  currentChangeOwed -= (amountOfDenomination * curr)
  acc.unshift(amountOfDenomination)
  return acc
}, [])

With `reduceRight`

Not much different, but I think it's a bit more readable with all denominations in ascending order.

let currentChangeOwed = 155
let denominationArray = [1, 5, 10, 25]

denominationArray.reduceRight((acc, curr) => {
  const amountOfDenomination = Math.floor(currentChangeOwed / curr)
  currentChangeOwed -= (amountOfDenomination * curr)
  acc.unshift(amountOfDenomination)
  return acc
}, [])

What the Difference?

reduce will traverse your array left to right
reduceRight will traverse your array right to left

Full Code With `reduceRight`

function makeChange(price, payment){

    const priceInCents = price * 100

    const paymentInCents = payment.reduce((acc, curr) => {
        return acc += curr * 100
    }, 0)

    if (priceInCents === paymentInCents){
        return [0, 0, 0, 0]
    }

    const changeOwed = priceInCents > paymentInCents 
        ? 
            paymentInCents 
        : 
            (paymentInCents - priceInCents)

    return calculateChangeOwed(changeOwed)
}

function calculateChangeOwed(changeOwed){
    let currentChangeOwed = changeOwed
    const denominationArray = [1, 5, 10, 25]    


    const changeArray = denominationArray.reduceRight((acc, curr) => {
      const amountOfDenomination = Math.floor(currentChangeOwed / curr)
      currentChangeOwed -= (amountOfDenomination * curr)
      acc.unshift(amountOfDenomination)
      return acc
    }, [])

    return changeArray
}

Show your solutions in the comments!

1.1 Comments

Quinn Lashinsky — Thu, 11 Mar 2021 17:05:17 +0000

This week we're gonna explore comments in Rust. Commenting in Rust serves a couple of purposes. Using regular comments we can explain how we implemented a solution or why we chose to implement that solution. Using documentation comments ("doc comments") we can document our code by explicitly describing how to use our code and how our code may behave in certain situations. Doc comments also provide us with some awesome functionality—Rust is able to auto-generate documentation based on the doc comments we made in our code. Whether we use regular comments or doc comments, Rust gives us two powerful conventions to explain our code to other humans who write code.

Let's see how we can take advantage of Rust's comment syntax rules to document our code as we write it.

Rust's commenting and documentation conventions
emphasize using line comments over block comments. Because of this, I'm gonna cover line comments and include some examples of
block comments at the end.

Regular Comments

We can create regular comments in Rust using // syntax.

// This is a line comment
let x = 5 + 5;

Documentation Comments

Inner Line Documentation Comments use //! and are useful for describing high level functionality of an entire crate.

We can think of a crate in Rust as either a binary or library.

A library crate contains useful utilities we can use within our projects (i.e. rand, which is a library crate containing utilities for number generation

A binary crate which is an executable, a machine code representation of the code we write. (i.e. an app, website, any program we create!)

Inner Line Documentation Comments use //! and are mostly used to provide top-level documentation to a crate you create.

usize lets our function know our number argument has to be number between 0 and 18446744073709551615. The usize after -> let's Rust know this function returns a number with the type of usize

    // ./src/lib.rs

    //! This inner documentation line comment documents our `./src/lib.rs` file.
    //! We've created a rust library crate which means `./src/lib.rs` 
        //! is the entry point of our code.
    //! When we compile our code, it starts with this file!

    fn add_one(number: usize) -> usize {
        return number + 1
    }

Outer Line Documentation Comments use /// and are the preferred way to document any other code you write.

    // ./src/lib.rs

    //! This inner documentation line comment documents our `lib.rs` file.
    //! We've created a rust library crate which means `lib.rs` is the 
    //! entry point of our code.
    //! When we compile our code, it starts with this file!


    /// This function will add the number you pass in by 1
    /// It will then return that number

    /// This is an outer documentation line comment because it exists before
    /// the function `add_five` we have defined below
    fn add_one(number: usize) -> usize {
        return x + 1;
    }

We are using Inner Line Documentation Comments to document the inside of our ./src/lib.rs file and Outer Line Documentation Comments outside of our add_one function to document our add_one function.

Using any form of documentation comment we can document our code using Markdown, specifically the CommonMark specification.

By supporting Markdown, Rust has given us a powerful, uniform convention to help us document our code. To really illustrate this, let's look at the documentation for Rust's standard library, std

We're currently looking at Rust's std or 'standard' library. Any project we create automatically have access to the entire standard library.

You should see a page that looks like this:

Do you see the [src] in the top right corner? I want you to open that link in a new window and compare the two, maybe like this:

Do you notice anything?

Do you see how the std library uses Inner Line Documentation Comments (//!) to document the top-level of the std library?

Do you see how each line with Inner Line Documentation Comments looks similar to the std library's generated documentation from those comments?

We can even see some Markdown used in creating an unordered list:

Built into Rust we get a powerful convention for documenting the code we write!

Now that we know the basics of using documentation comments we'll use cargo to create a library and some documentation for it.

You'll want to have Rust with the cargo package
manager installed on your local computer to get the
most out of this exercise, but you can also follow
along!

Check to see if cargo is installed by running:

cargo --version

Rust comes with a bunch of tools when you install it, one of them being rustdoc. rustdoc's purpose is to build documentation from our crate's entry point which is called our "crate root". When we build the documentation rustdoc turns it into HTML, CSS, and Javascript. rustdoc is a more low-level than cargo, and luckily cargo has commands that act as wrappers for rustdoc to make generating our documentation easier. If you want to learn more about rustdoc, you can look at the rustdoc book.

Now before we generate our documentation website, let's write a simple library with a couple of addition functions. Then we'll document it using all three types of comment!

Let's run cargo new addition_functions --lib to create our new Rust library. Then we'll run cd addition_functions. Open this in your favorite code editor and then open the ./src/lib.rs file and delete the code inside.

We should see something like this:

Congrats! You've just created a Rust library crate. A Rust library includes functionality that may be used by a binary crate or other library crates. For example, the std library handles the creation of built-in types for rust. We don't go off on our own and try to build an integer type, because it would most likely be a waste of time. Rust already provides us with multiple integer types in it's std library crate, so let's use them!

From here let's create a couple of functions. In [./src/lib.rs](http://lib.rs) we'll add this code:

pub makes our function public so that it will be included in documentation.

And then we'll run cargo doc --open. This command will generate our documentation and open it locally in the browser.

You can also run cargo doc to build documentation and not open it in a web browser.

When we use cargo, our documentation website is built within our ./target/doc/[name-of-library] folder, the entry point being the index.html file.

This means an alternative to running cargo doc --open would be running cargo doc and then open target/doc/[name-of-library]/index.html(in our case [name-of-library] will be addition_functions

So we have our two adding functions, now we should write some documentation to describe how they work. Let's use all three types of comments to document the purpose of our library.

Our Inner Documentation Line Comments to document our entire library:

Our Outer Documentation Line Comments to document our functions:

And finally some Regular Comments:

Here is a full code

Now that we've added some comments, lets re-build our documentation using cargo doc --open

We can see our Inner Documentation Line Comments (//!) which describe the entirety of our library. This is because they are top level within our [./src/lib.rs](http://lib.rs) file. Rust convention dictates that we only use this type of comment to give an overview of our crate's functionality—a general explanation of what functionality our crate provides.

Now below that we see our two functions with their Outer Documentation Line Comments (///). Remember, they are called Outer Documentation Line Comments because they are just before or "outside" of the code they comment on. In this case we're commenting on the add_five and add_ten functions respectively. Let's click the add_five function.

Now we see our function signature in addition to the rest of the outer documentation comments we wrote!

Finally, we'll check out our source code by clicking [src] in the top right corner. Now we'll be able to see our regular comments:

Remember, regular comments are useful for other developers working on/developing the library crate, while Outer/Inner Line Documentation is more useful for developers who are using your library crate.

This is a lot. We haven't even gotten to understanding types in Rust, but it seems very intentional to me that Rust By Example teaches commenting just after "Hello, World!", its first section. Commenting is a way to bridge the communication gap between developers, whether we comment on a line of code or create documentation for an entire library. Comments create documentation in Rust, and documentation can mean the difference between spending 5 minutes on a problem or 5 hours. Rust has excellent documentation. As we keep learning let's take advantage of it. Let's apply the knowledge we've learned today to search documentation for answers and learn Rust as solidly as we can.

EXTRA STUFF

We can search for documentation on docs.rs, an open source website that hosts all documentation for crates added to crates.io

Now let's give our documentation a little flair and learn about some of the ways we can make it more explicit, give it some minimal Markdown styling, and even some alternative syntax.

An Alternative Commenting Syntax

Both inner and outer documentation comments are syntactic sugar for the built in [doc=""] attribute. We can use them interchangeably like so:

Type of Comment	w/o Syntactic Sugar	w/ Syntactic Sugar
Inner Line Documentation Comments	#[doc="This is an inner documentation comment"]	/// This is an inner documentation comment
Outer Line Documentation Comments	#![doc"This is an outer documentation comment"]	//! This is an outer documentation comment

Markdown Syntax, Code Examples, and Testing

Some API Conventions

Rust crates include some common headings as convention (Errors, Safety, Example) we can use to describe how our code may behave in common use cases. Let's create an Examples header for our add_five, write a code example, and then test it.

Using Markdown syntax we can create a heading and called "Examples" above our add_five function. Let's see what that looks like:

Markdown will default to Rust, but it never hurts to be explicit about the language we are using.

From here, let's use the assert_eq! macro to see if our function is working as intended. If the two arguments we pass in are equal, the test will pass. Otherwise, it will fail.

Now if we run cargo test --doc, we'll only run our documentation test cases. In our console we'll see if the test cases passed or failed.

Looks like our test cases passed!

If you're feeling up to it, why don't you write some simple Example documentation for the add_ten function like we did above, for practice!

Block Comment Examples

Inner Block Documentation Comments

/*!
        This library has two functions
        that will add an integer to the integer you pass in.
!*/

pub fn add_five(number: usize) -> usize {
    return number + 5;
}

pub fn add_ten(number: usize) -> usize {
    number + 10
}

Outer Block Documentation Comments

/**
        Adds 5 to the integer passed in.
**/
pub fn add_five(number: usize) -> usize {
    return number + 5;
}

/**
        Adds 10 to the integer passed in.
**/
pub fn add_ten(number: usize) -> usize {
    number + 10
}

Regular Block Comments

pub fn add_five(number: usize) -> usize {
        /* 
             I chose to return explicitly here
           for clarity in a blog where we're learning
             how to write comments.
    */ 
    return number + 5;
}

pub fn add_ten(number: usize) -> usize {
        /* 
             I chose not to return explicitly here
           because we now know we can return explicitly in
       Rust, but we can also not include a ";" (semi-colon)
       and Rust will return that expression.
    */ 
    number + 10
}

Here's a handy table to remember all three types of comment, whether they are in line or block ****form.

Type of Comment	Line Comments (Very Common)	Block Comments (Uncommon)
Regular Comments	`//`	`/* ... */`
Inner Line Documentation Comments	`///`	`/ ... /`
Outer Line Documentation Comments	`//!`	`/! ... !/`

Type Conversion with String, Number, and Boolean Functions

Quinn Lashinsky — Tue, 02 Mar 2021 17:40:05 +0000

Whenever we write code, we should make an attempt to organize its meaning in powerful, expressive ways. While code helps us control computers, it is also read by humans and discerning meaning is arguably just as important as how a computer reads it. As we write more and more code, we'll find a need to coerce types, changing one type to a different type. Today we're gonna explore type conversions between string, boolean, number, undefined, and null types. Javascript gives us ways to make these conversions using the built-in Boolean, Number, and String functions. But how do we use them? And when should you take a different approach when making type conversions?

📖 - We'll also throw in NaN for good measure,
though it is good to note in Javascript NaN is technically a number type

📖 - Before we jump in, it's important to note the > difference between using the new operator vs. not using it.

This applies to three types we are looking at today.

/* 
 * Creates a Primitive Wrapper Object. 
 */

new String()

// String {""}

/* 
 * This Primitive Wrapper Object contains 
 * a set of built-in methods you can call. 
 */

new String("Hello").valueOf()

// "Hello"

/* Creates a string */
String("Hello")

// "Hello"

String

First up, we have the String function.

String Conversion

Type	Example	Result
Boolean (true)	String(true)	"true"
Boolean (false)	String(false)	"false"
Number	String(5)	"5"
String	String("1234")	"1234"
null	String(null)	"null"
undefined	String(undefined)	"undefined"
NaN	String(NaN)	"NaN"
no argument passed	String()	""

String is probably the most predictable of the three. For primitive data types, the String function takes in exactly what you type and turns it into a string.

String(arguments) is functionally the same as doing value + "".

Boolean

Now let's see how we can use the Boolean function!

Boolean Conversion

Type	Example	Result
Number (= 0)	Boolean(0)	false
Number (≠ 0)	Boolean(1), Boolean(-1000)	true
String	Boolean("Hello")	true
String (empty)	Boolean("")	false
null	Boolean(null)	false
undefined	Boolean(undefined)	false
NaN	Boolean(NaN)	false
no argument passed	Boolean()	false

Boolean will convert falsy values to false and truthy values to true.

Boolean and !! are interchangeable as they do the same thing.

For example:

const differentTypes = [NaN, 0, 1, true, "1234" null, undefined]

differentTypes.filter(Boolean) // same as array.filter(x => Boolean(x))

// [1, true, "1234"]

differentTypes.filter(x => !!x)

// [1, true, "1234"]

Number

Lastly, let's look at how the Number function works for common use cases in Javascript.

Number Conversion

Type	Example	Result
Number (= 0)	Boolean(0)	false
Number (≠ 0)	Boolean(1), Boolean(-1000)	true
String	Boolean("Hello")	true
String (empty)	Boolean("")	false
null	Boolean(null)	false
undefined	Boolean(undefined)	false
NaN	Boolean(NaN)	false
no argument passed	Boolean()	false

Number(new Date()) will give us the current date in milliseconds from the epoch

Number shines when making conversions from a string representation of a number, into a number. For example, let's look at a common case:

When we increment our value without using the Number function, because our value is a string type it will concatenate.

In Javascript, "0" + 1 === "01"

When we increment our value using the Number function, because we convert our value to a number type, we get our expected behavior.

In Javascript, 0 + 1 === 1

Number vs. parseInt/parseFloat

Number is wonderful for simple string to number conversions, but parseInt or parseFloat may be a more robust option if you are changing values with a unit attached.

parseInt("100px") // 100
parseFloat("100.23") // 100.23

Number("100px") // NaN

It's important to note that parseInt/parseFloat will only parse numbers up until it reaches a non-number, ignoring leading or trailing whitespace.

// parseInt and parseFloat yield the same results in this example

parseInt("a100") // NaN
parseInt("1a00") // 1

Number("a100") // NaN
Number("1a00") // NaN

This makes it so you can only use hexadecimal, octal, or binary numbers using their full string representation while using parseInt's second argument, radix. parseFloat does not take any arguments.

// Both function calls should return a binary representation of the number, 4

// Works as expected 
parseInt("100", 2) //4

// Does not work as expected
parseInt("0b100", 2) // 0

Through learning about the String, Boolean, and Number functions, we've learned when it might make sense to use them, and when an alternative is better. Learning code involves adding new information to your toolbox, employing you to write more semantic, expressive, easily readable code. Let these three functions be another piece helping you learn and build with code.

Introduction and 1.0 - Hello World

Quinn Lashinsky — Thu, 25 Feb 2021 18:33:45 +0000

Introduction

Rust By Example - Introduction

On the first page of Rust By Example, we're greeted with this statement:

Rust is a modern systems programming language focusing on safety, speed, and concurrency.

Awesome. But what does this mean?

Over the course of completing these exercises we'll explore how Rust language prioritizes and implements these qualities.

Hello World (Chapter 1.0)

Rust By Example - Hello World!

It's tradition to create a "Hello World" program whenever you learn a new coding language. But before we do, let's take a look at the top right of our in browser coding environment.

We can reset the code to it's original state by clicking the leftmost button
We can copy all of the code by clicking the middle button
We can run the code by clicking the rightmost button

If we click run we should see Hello World! below

The println! macro prints our text to the console. A macro in Rust isn't a function call although it may look like one. Instead, the contents of the macro expand into source code. That way the body of the macro explicitly writes code which is eventually executed. This is a form of meta programming. We are writing code (println!) that generates other code (code we put inside of println!). We'll look at macros more in a future post!

Lastly, we are given instructions on how to create a Rust binary in our local dev environment. Follow the instructions and you will have created an executable binary which will print out "Hello World!". An executable binary is a machine code version of any code we write. In this case, it's our "Hello World!" code!

We've completed our Hello World example!

In the next post, we'll cover the next chapter, 1.1 - Comments

Starting Rust By Example

Quinn Lashinsky — Thu, 25 Feb 2021 18:22:03 +0000

When I first started to learn how to code I remember being astounded by what I was able to do. Each new concept building on top of the previous, ultimately leading to the ability to build websites and web apps. I picked up Ruby, then Javascript, and while I became more infatuated with Javascript, in the back of my mind I knew I wanted to learn a more low-level language. I had been hearing about Rust for a bit, but wasn't sure. I thought I should probably try to learn Java, C, or C++. There were a couple of reasons that swayed me against this, and here I am making another attempt at learning Rust.

What were these reasons?

The Rust Community:

The Rust community has always felt welcoming and open. I don't feel the same negativity that can pervade communities around other languages.
Tooling Around Rust:

Rust is easy to install, provides useful built-in standardized utilities like testing and crate documentation and setting up Rust on my computer was simple.
Safety And Convenience Of Modern Programming Languages, With The Efficiency And Low Level Control That C and C++ Offer:

Rust has it's own set of programming paradigms that help ensure issues like managing memory are made easier to manage
WebAssembly - The Future of the Web:

WebAssembly looks to be the future of the web, looking to provide us with the ability to use any language to run code in the browser. Rust has already been involved, with tooling being defined for the spec.
Interoperability Among Types of Programming, specifically:
- Backend Engineering
- Frontend Engineering
- Systems Engineering

It really feels like Rust covers almost any area of programming I am or may become interested in!

How We'll Learn

The Rust website has a few recommended ways to start with Rust.

The Rust Book

An awesome resource that gives an overview of the language. I tried learning from the book first, but ultimately the ratio of reading to coding made it hard for me to stay engaged. We'll keep this in mind, and reference the book when necessary!

The Rustlings Course

Great for doing Rust based exercises on your machine, but it's less hands on. I found I was either applying or researching knowledge I found in the Rust Book to solve each problem and became stuck regularly. You are thrown into the deep end, and to some degree, must figure out how to solve each problem.

Rust By Example

We are going to use Rust By Example. It combines elements of the Rust Book while incorporating coding exercises. You can do exercises in the browser using the Rust Playground, but I suggest you install Rust on your local machine. You can even find editor support here

Rust has awesome built-in tooling and we can reference the Rust Book when working through problems.

We're going to cover each chapter in order, including the linked resources at the bottom in depth.

Here's to joining me on this journey to learn Rust!

Foreign Key Constraints with knex.js to Ensure Database Atomicity

Quinn Lashinsky — Tue, 23 Feb 2021 16:25:31 +0000

Over the course of building Flashcards, my Quizlet-like clone, I wanted to make sure that if I delete a card_set all of its flashcards would be deleted as well. I tried to handle this myself, but this became a nightmare of bad logic and edge cases. Eventually, I took a step back and tried to examine the problem I was really trying to solve. My database is my single source of truth for all data in my application. Is it possible for my database to safely handle the above operation? It is! By adding foreign key constraints to my knex migrations I can take steps to ensure database atomicity within my Postgres database.

What Is Database Atomicity?

"An atomic transaction is an indivisible and irreducible series of database operations such that either all occur, or nothing occurs." - Wikipedia

This means my database will guarantee that if I try and delete a card_set and its flashcards, either that card_set and it's flashcards are both deleted, or neither are deleted.

What Is A Foreign Key?

A foreign key is a reference to the primary key of another table. Foreign keys make it easy for us to establish relationships between tables.

Before we jump into the code, let's look at the relationship I have setup for my card_sets and flashcards. My card_sets table is a parent table to my flashcards child table.

A parent can have many children but a child can only have one parent, just like a card_set can have many flashcards, but a flashcard can only belong to a singular card_set. This relationship can also be described as a "has many/belongs" to relationship. A card_set has many flashcards, but a flashcard belongs to only one card_set.

In order to establish this "parent/child" or "has many/belongs to" relationship, I have to set up foreign key constraints. This is what my foreign key constraint looks like with knex, the SQL query builder I am using.



// Part of My Flashcards Migration File

  // This code creates my "card_set_id" column as a 
  // not nullable UUID type
    table
      .uuid("card_set_id")
      .notNullable()
      .references("id")
      .inTable("card_sets")
      .onDelete("CASCADE");

These three functions will help us define our foreign keys and their behavior:

References

The column.references(column) function tells us what primary key value to reference as our foreign key.

In our code above we are saying we are going to reference the id column in some table (we haven't defined which table yet!) as the primary key to our card_set_id foreign key.

Now we have to specify which table's id column we would like to use the primary key value from.

inTable

The column.inTable(table) function lets us define exactly which table we'll get our primary key value to use as a foreign key.

In our code above we explicitly use the card_sets table. Now we have bound the two, and formed a relationship between tables

flashcards.card_set_id is the foreign key to card_sets.id

onDelete

The column.onDelete(command) function allows us to define how we'd like all child rows with this foreign key (flashcards.card_set_id) to behave when their referenced parent row is deleted (card_sets.id).

I'm working with Postgres, keep in mind not all SQL database implementations will accept these commands:

CASCADE - When the parent row is deleted, all children rows referencing the parent are deleted as well
SET NULL - When the parent row is deleted, all children rows with a foreign key referencing the parent row will be set to the value "NULL"
RESTRICT - If a child row references a parent row, no parent and or child rows will be deleted
NO ACTION

Guaranteed Database Atomicity

Now the problem is solved! If I delete a card_set my PostgreSQL database will guarantee that all flashcards associated with that card_set are deleted as well.

Postgres will handle the entire transaction. If the transaction fails, my card_set and its associated flashcards will return to the state they were in before the transaction occurred. If the transaction succeeds, then I know both the card_set and associated flashcards are deleted!

Snow Days and Javascript Promises

Quinn Lashinsky — Wed, 10 Feb 2021 18:42:05 +0000

Your eyes are glued to the TV. You watch the news in awe, just waiting for them to get to the weather forecast. You haven't had a snow day all year, and you're hoping that tomorrow will be the first. You think of all the things you'll be able to do—Drink hot chocolate, watch a movie, sleep in, sled, build a snowman with a bunch of friends. It all sounds so amazing.

Finally, the weather forecast comes on and they are promising snow tomorrow!

let snowPromise = new Promise((resolve, reject) => {
  // Our Promise function
});

Now all we can do is wait! We don't know whether it will snow or not, and we won't know until tomorrow. We then find out if it snows our school district will announce school closures at 7am tomorrow! It's currently 6pm. We have 13 hours until this prediction proves to be true or false!

You are elated. So happy, you almost miss the forecaster tell you that there's only 30% chance of snow happening. If it snows, school will be closed.

You're gonna be absolutely devastated if it doesn't!

function willItSnow() {
  return Math.random() < 0.3;
}

let snowPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    if (willItSnow()) {
      resolve("School's Closed");
    }
    reject("School's Open");
  }, 46800000); // 13 hours in milliseconds
});

console.log(snowPromise);

// Promise {<pending>}

It looks like things are in motion! Our snowPromise will act as a placeholder, waiting for an asynchronous operation to complete (in our case a setTimeout), resolving or rejecting with data. In our case, 13 hours later.

That's a long time to wait...what're we gonna do between now and our predicted snowfall?

If we didn't use a Promise we wouldn't be able to do things like perform our snow-bringing bed time rituals. We would be blocked from doing anything else. We'd just sit on the ground waiting to hear if school is closed or not for 13 HOURS. This sounds like a huge waste of time!

The asynchronous nature of a Promise lets us run other code while we wait for our Promise to resolve or reject. While this happens, we can go ahead with leaving a spoon under our pillow and flushing ice cubes down the toilet. This will definitely ensure we get snow tomorrow!

It's been an exciting day and we still don't know whether it will or won't snow.

To get ready, we'll turn our PJ's inside out and look forward to our snowPromise result in the morning!

Next Morning

We wake up! We're excited! But we're unsure of whether school is closed or not. We need to hear it from the source. But how do we find our information?! Listening to the radio, tv, or reading information on the internet may help us figure out if school is closed or not. These are conduits for receiving the information, much like Promise methods we are going to discuss below!

Promise's have a few methods that will allow us to handle our eventual returned result.

Promise Methods

We can handle a Promise using 3 different types of promise handlers; .then(), .catch(), .finally()

Then

.then(onFulfilled, onRejected) - This method will let us handle a success and error cases, which are technically called our onFulfilled and onRejected handlers.

Both of these parameters must be functions.

function willItSnow() {
  return Math.random() < 0.3;
}

let snowPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    if (willItSnow()) {
      resolve("School's Closed");
    }
    reject("School's Open");
  }, 1000);
  // We'll use 1 second here and going forward so we don't have to wait for
  // 13 hours for our Promise to resolve
});

snowPromise.then(
  // onFulfilled
  (value) => {
    console.log(value);
  },
  // onRejected
  (error) => {
    console.log(error);
  }
);

// If it snows, below will be logged to the console:
// "School's Closed"

// If it doesn't snow, below will be logged to the console:
// "School's Open"

If our snowPromise resolve's, it will pass any arguments we passed to our resolve function to our onFulfilled handler function.

If our snowPromise reject's, we'll pass any arguments we passed to our reject function to our onRejected handler function.

Finally, we're able to tell whether school is closed or not!

Put the above code into your chosen Web Browser's console or a program like RunJS.

Is School Closed?! That's amazing! That means our Promise resolved and our onFulfilled function ran! Let's go play in the snow!

Is School Open?! That's unfortunate! That means our Promise rejected and our onRejected function ran. Time to get ready for school...

This may seem a bit cluttered to you though. It may be useful to have both possible paths within our .then() handler, but we can also use a different method to handle our onRejected function...

Catch

.catch(onRejected) - This method will let us handle our error case, which is technically called our onRejected handler

function willItSnow() {
  return Math.random() < 0.3;
}

let snowPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    if (willItSnow()) {
      resolve("School Closed");
    }
    reject("School Open");
  }, 1000);
});

snowPromise
  // onFulfilled
  .then((value) => console.log(value))
  // onRejected
  .catch((error) => console.log(error));

// If it snows, below will be logged to the console:
// "School's Closed"

// If it doesn't snow, below will be logged to the console:
// "School's Open"

This method makes it easier to break apart our success and failure/error states!

TIP: We can even chain a bunch of .then()'s together and add a single .catch() at the end to handle any error from our Promise or any previous .then()

Lastly, we know we'll always want more snow. Multiple snow days in a row? That sounds like heaven!

Finally

.finally(onFinally) - This Promise method allows us to execute some code whether or not our Promise resolve's or reject's.

function willItSnow() {
  return Math.random() < 0.3;
}

let snowPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    if (willItSnow()) {
      resolve("School Closed");
    }
    reject("School Open");
  }, 1000);
});

snowPromise
  // onFulfilled
  .then((value) => console.log(value))
  // onRejected
  .catch((error) => console.log(error))
  .finally(() => console.log("🤞🏽⛄️ PLEASE SNOW TOMORROW ⛄️🤞🏽"));

// If it snows, below will be logged to the console:
// "School's Closed"
// "🤞🏽⛄️ PLEASE SNOW TOMORROW ⛄️🤞🏽"

// If it doesn't snow, below will be logged to the console:
// "School's Open"
// "🤞🏽⛄️ PLEASE SNOW TOMORROW ⛄️🤞🏽"

Well...are you going to school today? Or do you have the day off? Either way, we'll always hope for more snow.

Let's bring this home with some final considerations to remember when using Promises.

Final Considerations

In Javascript, all asynchronous code will only run if there are no other functions on the Call Stack

So for example:

new Promise((resolve, reject) => setTimeout(resolve, 2000)
    .then(() => {
        console.log("1")
    })

console.log('2')

// 2
// 1

If you want access to a result in multiple chained .then() methods, you must return the result from each .then()

No Return -

new Promise((resolve, reject) => {
  resolve("Resolve Function");
})
  .then((value) => {
    console.log(`1 - ${value}`);
  })
  .then((value) => {
    console.log(`2 - ${value}`);
  });

// "1 - Resolve Function"
// "2 - undefined"

Return -

new Promise((resolve, reject) => {
  resolve("Resolve Function");
})
  .then((value) => {
    return value;
  })
  .then((value) => {
    console.log(`1 - ${value}`);
  });

// "1 - Resolve Function"

❄️ Now let's get back to having a snowball fight! ❄️

Summing an Array with Nested Arrays

Quinn Lashinsky — Tue, 26 Jan 2021 15:04:34 +0000

(Throughout this article I will be using the terms list and array interchangeably. The Python list type is called an array in many other programming languages)

Summing an array can be done in many ways. In Python we can use a for...in loop. We even have a built in sum function we can use to sum an array. These solutions work perfectly for a 1D array, but how can we sum a 2D array? Let's break this problem into smaller pieces and solve it.

Today we are going to solve two problems—summing an array and any of its nested arrays

First, let's sum an array:

sum([1,2,3,4,5])

# 15

Well that was easy! This helper function provides an easy way to sum all values, but what is the sum function actually doing? Something like this maybe?

def sumOfArray(array):
    sumTotal = 0
    for number in array:
        sumTotal += number
    return sumTotal

Each number in the array will be added to the current sumTotal and then we set that value as the new sumTotal.

After we finish iterating, we return the sumTotal. We've accomplished the first step of our goal! Now on to the next step, summing any arrays within our array.

But wait a second, haven't we already figured out how to sum an array? Let's write out the problem in pseudo-code

Currently, we have figured out this much:

def sumArrayofArrays(array):
    # create variable to hold sum of array (`sumTotal`)
    # iterate through array and add each number to the sum
    # return the sum

We know this function will sum an array, so how can we call it on each nested array?

Number or Array?

Right now in our loop, we're calling our variable number, but we know it may not always be a number. For example, if this is our array:

array = [1,2,3,[4,5]]

array[0] # 1 - Number
array[1] # 2 - Number
array[2] # 3 - Number
array[3] # 4 - Array

The 3rd position in our example is a list type! Let's update our loops variable name in order to be more accurate. Let's use element.

def sumOfArray(array):
    sumTotal = 0
    for element in array:
        sumTotal += element
    return sumTotal

We now know an element can either be a list or int type. If an element is an int we want to add it to the sumTotal which we're currently doing, but is there a way to check if an element is a list?

Type()?

In Python, we can determine the type of anything by using the type function.

type(3) # <class 'int'>
type([]) # <class 'list'>
type(type) # <class 'type'>

The type function will allow us to check if an element is a list. Let's add that check to our function!

def sumOfArray(array):
    sumTotal = 0
    for element in array:
        if type(element) is list:
            # do something
        else:
            sumTotal += element
    return sumTotal

The Final Piece

Whenever we reach a list in our array, we know we want to sum all values within that our nested arrays, but how can we do this?

Well, we've already defined a function that can iterate through a list and return it's sum, so we can call our sumOfArray function recursively and solve our problem outright!

def sumOfArray(array):
    sumTotal = 0
    for element in array:
        if type(element) is list:
            sumTotal += sumOfArray(list)
        else:
            sumTotal += element
    return sumTotal

Now that we've defined our function and walked through the process used to create it, let's take a look, step by step and look at what is happening on each line. I know that I find it so much easier to conceptualize and visualize code execution by stepping through the code line by line. Using a debugger or getting a pen and paper tend to be the most helpful for me.

Let's take a simple example incorporating an array with a number and a nested array.

# array = [1, [2]]

We'll use VSCode's built-in Run and Debug tab and take it step by step and explore the space and time complexity of our function.

On the left side of the screen we can see two important parts of our code execution. In the top left we can see how our variables change over time and in the bottom left we can see our call stack.

Ultimately, because we are going to access all values in the array, this means our Time Complexity is O(n) with n being the length of the array

Out Space Complexity is dependent on the max amount of calls we have on the call stack at a given time.

Every time we call a new function, it is put on the call stack. When the function finishes executing, we remove or "pop" it from the call stack. Each function call takes up space on the call stack.

This means for each array that has a nested array, we will call our sumOfArray function and add it to the call stack. This means the depth of the most nested array, which is directly related to the amount of sumOfArray function calls on the call stack, is our Space complexity.

For example:

# Each nested array pushes another `sumArray` function to onto the stack

firstArray = [1,[2]]

# Max Depth - 2

sumOfArray(firstArray) 

# 3
# Time Complexity - O(n)
# Space Complexity - O(d) (Here 'd' is 2)

secondArray = [1,[2,[3]]]

# Max Depth - 3

sumOfArray(secondArray)
# 6
# Time Complexity - O(n)
# Space Complexity - O(d) (Here 'd' is 3)

Feel free to play around with code! Run it in your own local VSCode setup or even write out each step.

Recursion

To solve our problem we used a programming technique called recursion.

Recursion allows us to break our problem down into its smallest pieces, solve those smallest pieces, which will help us find our final result.

Every time an element is of type list , a new call to sumOfArray will be added to the stack

If a list has no nested arrays it will return it's sum.

If it has a nested array, when that array is reached during iteration, it will add another call to the stack.

This will repeat until we reach the most deeply nested array. Then as each call returns it's array's sum, each sumOfArray function on the stack will be popped off, eventually returning us the sum of all values in the original array and it's nested arrays.

I highly recommend using pen and paper and a simple input array to see exactly how recursion has helped us solve the our problem here. It can be a highly useful tool to help us solve problems like this, where it seems hard to find an iterative solution!

Steps to Creating A Compose Function

Quinn Lashinsky — Wed, 08 Jul 2020 17:16:04 +0000

Functional composition looks something like this.

function first(x) { 
  return x + 1
}

function second(x) { 
  return x + 2
}

console.log(second(first(1)))

// 4

We work from inner to outer. In the example above, we call the innermost function, first(1), and pass the result of that function, 2, to the invoked second function. When we call the second function it'll look like this: second(2). Finally, when second(2) executes we get our returned value, 4. We've composed a bunch of simple functions to build more complicated ones.

Using functional composition we can break our code into smaller reusable pieces. We can then use those pieces as building blocks for creating larger functions. Each piece being a set of instructions, clearly indicating exactly how we are manipulating our data. But how can we create a compose function?

Let's build our model up in pieces. We'll look at the idea of a function as a first class citizen, and what that means in Javascript.

MDN says,

A programming language is said to have First-class functions
when functions in that language are treated like any other
variable. For example, in such a language, a function can be > passed as an argument to other functions, can be returned by > another function and can be assigned as a value to a
variable.

Two takeaways here. In order for a language to have first-class functions, functions must be able to be:

Passed as arguments to other functions
Returned from another function

Functions As Arguments

If you've ever used the Array map or forEach
function in Javascript you've already seen functions as arguments.

let numbers = [1, 2, 3, 4]

function square(x){
  (x) => x * x
}

let squaredNumbers = numbers.map(square)

console.log(squaredNumbers)
// [1, 4, 9, 16]

The map function will call our square function on every element in the numbers array, and push the return value of our square function into a new array. Once there are no more elements to invoke our square function on, the new array is returned.

This is a simplified version of what a map function definition might look like:

function ourMap(array, fn) {
  let newArray = []

  for (element of array) {
    newArray.push(fn(element))
  }
  return newArray
}

In ourMap, our passed function argument is invoked on each member of the array.

Functions As Return Values

We've seen how we use functions as arguments, but what about returning a function from a function?

It's possible!

function multiplier(x) { 
    return function(f) {
        return x * f
    }
}

let multiplyByTwo = multiplier(2)

console.log(multiplyByTwo(10))
// 20

Here the inner function knows about "x", it's within its scope, so when we call multiplier(2) we return a function that looks like this

function (f) {
    return 2 * f
}

Now when we invoke multiplyByTwo, we'll invoke the function we return from our "multiplier" function. That means when we call "multiplyByTwo(10)" we get 20.

console.log(multiplyByTwo(10))

// 20

The returned function still has access to all defined variables in the closure it was created in. This is why our "multiplyByTwo" function has access to the number 2 we passed to "multiplier" when creating our "multiplyByTwo" function.

Compose Function

In order to create our compose function we're gonna want to take in any number of functions and any number of arguments to pass to each function.

This sounds a bit daunting, but luckily we can take advantage of the arguments array-like object and the Array.prototype.reduce function.

The arguments array-like object is not an array, and does
not have certain functions or properties associated with it that an array might have. That being said, you can convert it to an array using the Array.from
function if you need an array.

I'm gonna write out the entire function, so we can examine and break it down into pieces. By the end, we'll be able to compose our own understanding of a compose function!

1 function compose(...fns) {
2   return fns.reduce(
3     function reducer (accumulator, current) {
4       return function returnedFunc(...args) {
5         return accumulator(current(...args))
6      }
7     }
8  )
9 }

Let's break it down line by line.

Line 1

We declare our compose function and use the spread operator to copy all of the functions we're receiving as arguments. This is technically the arguments array-like object for our compose function, but we'll call it "fns" because those arguments will only ever be functions.

Line 2

Here we're gonna run reduce on this arguments array.

Line 3

The reduce functions takes a reducer function. Here, the "accumulator" will start at the first element in the "fns" arguments array, and the "current" will be the second.

Line 4

Here comes our returned function! The function will be returned when we invoke compose.

At this point, I think it would be helpful to see this in action.


let addAndMultiplyItself = compose(
  function multiply(x) { return (x * x) }, 
  function add(x){ return (x + x) }
)

console.log(addAndMultiplyItself)

// [Function: returnedFunc]

We've now saved our returned function into a variable and it has access to the environment in which it was defined. This means it has access to functions we passed in on line 1.

Line 5

When we call addAndMultiplyByItself, and pass in our argument(s), the reduce function will execute from innermost to outermost.

Here's the function call:

let addAndMultiplyItself = compose(
  function multiply(x) { return (x * x) }, 
  function add(x){ return (x + x) }
)

console.log(addTogetherAndMultiply(10))

Here's what happens as the reducer executes:

iteration	accumulator	current	args	returned value
1	multiply	add	10	400

When we invoke the function returned from compose with the argument 10, addTogetherAndMultiply(10), we run every single function compose takes as an argument on the number 10, innermost to outermost as we reduce.

Composing our functions gives us more control over adding and removing functions that may not suit a particular use case.

We can build many reusable, modular functions by following a functional composition model.

Making My First Open Source Contribution

Quinn Lashinsky — Fri, 12 Jun 2020 20:11:58 +0000

For the past two days I had been checking Trello for a ticket that I thought I could complete. Finally, I found one! ...and I spent 10 minutes reasoning back and forth whether I could do it. I was paralyzed with fear. Could I accomplish this? Did I have the skills? Would my work be worthy enough to put into production?

I was extremely unsure if I could pull through. I mustered up the courage to ask the Team Lead if I could take the ticket. They gave me the go ahead.

I took a deep breath and I took the ticket.

The ticket involved adding clickable arrows to a pagination component. I had to make it so a user could click to go to the next or previous page. I had to take into account mobile and desktop styling, and I had to work with Chakra UI, a library I had no experience using.

The majority of the component was already built, but looking through the file only made me more confused than I had initially been.

After taking another deep breath I formulated a plan based on advice I had been given from the coding bootcamp I had attended, from a summer internship I had done, and hours of searching stack overflow. This was the process that helped me from beginning to end.

Write Down Ticket Requirements

I wrote down a list of every requirement I had to fulfill to complete the ticket. This let me see the exact amount of work I had to do, making it less cloudy what the end goal would look like.

Understand the File(s)

I took my time reading and examining the files. I attempted to get a high level overview of how the logic was affecting the view. Piecing together how each piece functioned to create the whole component gave me a quick look into how the component worked.

Change, Reload, Change, Reload

I took my time adjusting variables I thought might be related to fulfilling the requirements of the ticket. This helped me to get a deeper understanding of how the state, functions, and variables in the component work together.

Some tools I used beside directly changing code were

javascript console.log

and

javascript debugger

. These two were able to give me a good idea if I was getting back the values I expected and if my code was executing how I expected.

Note: If you become confused and want to clean the slate and remove all changes you made on unstaged files (files are not added or committed) run

git git checkout .

in your terminal and all the changes you made will be discarded. You can also discard changes in individual files using

git git checkout [FILE PATH HERE]

i.e.

git git checkout src/components/Pagination.js

Write Down Steps to Complete Ticket

After I had decent understanding of what the pagination component was doing, I decided to write out how I could possibly complete each task step by step.

All in all, it took me about 6 hours. I tried new things, combed at Chakra UI documentation and asked many questions. The thing I most struggled with were conventions used within the project. It's tempting to copy what other people are doing, but I tried to focus on why these decisions were made. I didn't want to emulate code as a default, because it could yield unintended side effects that could confuse me.

This was where having such a great team of volunteers and Team Leads helped. I started out unsure and wary of whether I could accomplish contributing to open source, but the above steps helped me to focus on the task at hand. I submitted my PR confident that the work I had done was worthy.

It was merged the next day and I made my first contribution to open source! 🥳

Some open source projects will list issues with labels denoting them as good first source contributions, and I think if you feel comfortable enough with the technologies used or even a bit challenged, it may be worth it to take on the issue. I'm definitely still hesitant, but I know I'm gonna fight this feeling and make more contributions. Worst that happens is it doesn't get merged. But there will always be more open source to contribute to!

The project I was able to contribute to is Rebuild Black Business which just launched today!

It is an open source project to help black businesses survive as they navigate the age of COVID-19 and dealing with the aftermath of looting. Ultimately, it's an awesome site that provides resources to black business owners who need aid. You can even list yourself as an ally-- someone who is willing to be contacted and help black business owners!

I encourage those reading this post to take a look and contribute if they can. The entire team is volunteers and they put this together in about 2 weeks.

Using Template Repositories w/ GitHub

Quinn Lashinsky — Wed, 06 May 2020 20:17:03 +0000

Abstractions are a key part of writing concise, useful code. When we create abstractions we write less code, reuse more code, and make our programs more clear and understandable. While working on building yet another server for a project idea I had, I realized I was coding the same boilerplate I had coded multiple times before. I was not abstracting this process effectively. How could I create a template repository (repo) with an already made repo?

The Do-It-Yourself Option

We can choose a repo to treat as a template. From there we have to decouple the template from its remote origin, and add a new remote origin repo to push to, creating our new project.

Let's walk through the steps:

First we'll go to the repo on GitHub you're going to treat as a template and copy the repo's git clone command.

In your command line, paste the command you copied. It should look something like this without the angle brackets ("<" and ">") :

git clone git@github.com:<your-username>/<your-template-repo-name>.git

From here, we can add the name of the folder we want this repo to clone into as the last argument of this command.

git clone git@github.com:<your-username>/<your-template-repo-name>.git <file-name>

If the file already exists, the repo will clone into that file. If it does not exist, the file will be created and then the repo will be cloned into it.

*Helpful Tip:

git remote -v

This command will tell you where your current repo points to as its origin

Then, we can change the origin url by running the below command. The origin url is the alias for a remote repo, which for our purposes, is the version of this repo stored on GitHub's servers.

git remote set-url origin git@github.com:<your-username>/<target-repo-for-new-project>.git

Now we're set! We've used a de facto template repo to create a new project repo structured just how we like.

The Automatic Way

We've just manually created a template repo. But is there a reason to manually handle this process each time you create a new template/project?

Luckily websites like GitLab and GitHub have added the ability to let you use any of your repo's as a template repo. Let's see how we can create a template repo on GitHub.

Go to Settings tab on the repo page you want to make a template repo.

Right below the name of the repo, we can click a checkbox to turn the current repo into a template repo.

That's all it takes!

Now whenever we create a new repo, we'll be given the option to use a template repo at the top of the page. This will create our repo with the base file structure defined in our template. From here we can clone the repo, and get to work.

We'll even see a reference to the template repo below the heading that includes our GitHub username and repo name.

Creating a template repo can help you think about just how to to design the base architecture of any project you create. Reasoning about design decisions like using an ORM, SQL or NoSQL, or including authentication are all up to you. Once made, you can continually update the code to suit your needs. By creating a template repo we can abstract the work that is common across projects, and confidently create projects with shorter development time.

DEV Community: Quinn Lashinsky

Pausing Rust By Example

Making Change Algorithm

The Problem

My Pseudo-Code

My Solution

Some Explanations

Why Did I Convert All Monetary Values to Cents?

Is This Code D.R.Y?

With reduce

With reduceRight

Full Code With reduceRight

1.1 Comments

Regular Comments

Documentation Comments

EXTRA STUFF

An Alternative Commenting Syntax

Markdown Syntax, Code Examples, and Testing

Block Comment Examples

Inner Block Documentation Comments

Outer Block Documentation Comments

Regular Block Comments

Type Conversion with String, Number, and Boolean Functions

String

String Conversion

Boolean

Number

Number vs. parseInt/parseFloat

Introduction and 1.0 - Hello World

Introduction

Hello World (Chapter 1.0)

Starting Rust By Example

How We'll Learn

The Rust Book

The Rustlings Course

Rust By Example

Foreign Key Constraints with knex.js to Ensure Database Atomicity

What Is Database Atomicity?

What Is A Foreign Key?

References

inTable

onDelete

Guaranteed Database Atomicity

Snow Days and Javascript Promises

Next Morning

Promise Methods

Then

Catch

Finally

Final Considerations

Summing an Array with Nested Arrays

Number or Array?

Type()?

The Final Piece

Recursion

Steps to Creating A Compose Function

Functions As Arguments

Functions As Return Values

Compose Function

Line 1

Line 2

Line 3

Line 4

Line 5

Making My First Open Source Contribution

Write Down Ticket Requirements

Understand the File(s)

Change, Reload, Change, Reload

Write Down Steps to Complete Ticket

Using Template Repositories w/ GitHub

The Do-It-Yourself Option

The Automatic Way

With `reduce`

With `reduceRight`

Full Code With `reduceRight`