DEV Community: Tatiana Bowman

Conversion Functions: converting between binary, hexadecimal, decimal, & ASCII

Tatiana Bowman — Fri, 05 May 2023 16:56:44 +0000

Conversion functions help computer programs to change information like numbers or letters from one type to another. For example, we can use conversion functions to change the number "10" into its binary equivalent "1010". Conversion functions are important because computers work with different types of information and formats, and sometimes they need to change one type of information into another to perform a specific task or operation.

In order to convert those types we need tools like built-in functions to help us. More specifically the built in functions: parseInt(), toString(), charCodeAt(), String.fromCharCode(), and substring(). Before I show you some examples of the usage, let me explain what binary, hexadecimal, decimal, & ascii are as well as what exactly the built-in functions do.

What are binary, hexadecimal, decimal, & ascii?

Binary (also known as Base-2) is a numbering scheme in which there are only two possible values for each digit, 0 or 1 and these are also the values that computers happen to be stored in. Binary numbers are often represented with 0b at the beginning.

0b11001010

side note: The word bits is short for binary digits and a group of 8 bits is known as a byte.

Hexadecimal (also known as Base-16) is often used as shorthand for representing binary values: one hex digit can represent four bits. The digits are 0-9 with A-F representing 10-15. A hexadecimal is often represented with 0x at the beginning.

 0xF23C

Decimal (also known as Base-10) is the most commonly used system. It uses 10 symbols (0-9), to represent numbers.

ASCII (which is short for American Standard Code for Information Interchange) is a character encoding system that assigns unique numerical codes to represent a set of characters used in computers. It's a seven-bit code meaning it can represent up to 128 characters, including numbers, letters, punctuation marks, and control codes.

ASCII CODE FOR "B" => 01000010 in binary

Built-in functions: parseInt(), toString(), charCodeAt(), String.fromCharCode(), and substring()

parseInt() is a function that parses a string argument and returns an integer of the specified radix (the radix or base is the number of unique digits, including the digit zero, used to represent numbers.)

parseInt(string, radix)

toString() returns a string representing the object

let number = 1;
number.toString();
=> "1"

But it can also be used to convert decimals into binary or hexadecimal by taking the radix that specifies the base of the number system to be used for conversion.

binary: base-2 => radix = 2 | hexadecimal : base-16 => radix = 16 | decimal: base-10 => radix = 10

example: 

let number = 255;
let hex = number.toString(16);
=> "ff"

charCodeAt() returns an integer between 0 and 65535 representing the UTF-16 code unit at the given index.

function charGreeting(greeting) {
  let greetCode = [];

for(let i = 0; i < greeting.length; i++) {
 greetCode.push(greeting.charCodeAt(i))
}
return greetCode;
}

charGreeting("Hey")
=> [104, 101, 121]

H => 104
e => 101
y => 121

String.fromCharCode returns a string created from the specified sequence of UTF-16 code units.

function charGreeting(charCode) {
  let greeting = [];

for(let i = 0; i < charCode.length; i++) {
 greeting.push(String.fromCharCode(charCode[i]))
}
return greeting.join("");
}

stringCharCode([104, 101, 121]
=> "hey"

Substring returns the part of the string from the start index up to and excluding the end index, or to the end of the string if no end index is supplied.

let name = "Tatiana"
name.substring(3)
=> "iana"

Conversion Function Examples & Breakdowns

converting binary and hexadecimal to decimals

const convertingBinarytoDecimal = binary => {
  let binaryRemoval = binary.substring(2)
  let decimal = parseInt(binaryRemoval, 2)
  return decimal;
}

convertingBinarytoDecimal('0b0101')    
=> 5

First the function removes the first two characters of the binary string, which are the prefix 0b, and stores the resulting string in the variable binaryRemoval.

The function then uses the parseInt function to convert the binaryRemoval string to a decimal number. The 2 radix (base) is passed as the second argument to parseInt, indicating that the input is a binary number. The resulting decimal value is stored in the variable decimal.

Finally, the function returns the decimal value.

note: something you will notice is that converting binary and hexadecimal are done the exact same way, the only differences are the base numbers.

const convertingHexToDecimal = hexadecimal => {
 let hexRemoval = hexidecimal.substring(2)
 let decimal = parseInt(hexRemoval, 16)
 return decimal;
}
convertingHexToDecimal('0x51')   
=> 81

converting decimals to hexadecimal and binary

const convertingDecimalToBinary = decimal => {
   let binary = decimal.toString(2)
   return `0b${binary}`
}

convertingDecimalToBinary(13) 
=> '0b1101'

First, the function converts the decimal number to a binary string by calling the toString method on the decimal variable with a 2 radix (base) as the argument. The resulting binary string is stored in the variable binary.

Finally, the function concatenates the string 0b with the binary string and returns the resulting string, which represents the binary equivalent of the original decimal number.

function convertingDecimalToHexadecimal(decimal) {
  let hex = decimal.toString(16)
  return `0x${hex}`
}

convertingDecimalToHexadecimal(9) 
=> '0x9'

converting binary to hexadecimal and hexadecimal to binary

const convertingBinaryToHex = binary => {
  let binaryRemoval = binary.substring(2)
  let decimal = parseInt(binaryRemoval, 2)
  let hex = decimal.toString(16)
  return `0x${hex}`
}

convertingBinaryToHex('0b1010')
=> '0xa'

The function starts by removing the first two characters of the binary (0b) and stores the resulting string in the variable binaryRemoval. Then converts the binary number to decimal by calling the parseInt function with the binaryRemoval string as the first argument and the 2 radix (base) as the second argument. The resulting decimal number is stored in the variable decimal.

Next, the function converts the decimal number to hexadecimal by calling the toString function on the decimal variable with the 16 radix as the argument. The resulting hexadecimal string is stored in the variable hex.

Finally, the function concatenates the string 0x with the hex string and returns the resulting string, which represents the hexadecimal equivalent of the original binary number.

const convertingHextoBinary = hex => {
  let hexRemoval = hex.substring(2)
  let decimal = parseInt(hexRemoval, 16)
  let binary = decimal.toString(2)
  return `0b${binary}`
}

convertingHextoBinary('0xa1')  
=> '0b10100001'

converting binary and hexadecimal to ASCII

const convertingBinarytoASCII = (binary) => {
  const binaryPrefixRemoval = binary.substring(2)
  const decimal = parseInt(binaryPrefixRemoval, 2)
  return String.fromCharCode(decimal)
}
convertingBinarytoASCII("0b01000010")
=> B

First, the function removes the first two characters of the binary string, which are the prefix 0b, and stores the resulting string in the variable binaryPrefixRemoval.

The function then converts the binary number to decimal by calling the parseInt function with the binaryPrefixRemoval string as the first argument and the 2 radix (base) as the second argument. The resulting decimal number is stored in the variable decimal.

Finally, the function uses the String.fromCharCode method to convert the decimal value to its corresponding ASCII character. The ASCII character is returned by the function.

const convertingHextoASCII = (hex) => {
  const hexPrefixRemoval = hex.substring(2)
  const decimal = parseInt(hexPrefixRemoval, 16)
  return String.fromCharCode(decimal)
}

convertingHextoASCII("0x43")
=> C

converting decimal to ASCII and ASCII to decimal

const convertingDecimalToAscii = decimal =>  {
  return String.fromCharCode(decimal)
}

convertingDecimalToAscii(65) 
=> "A"

The function uses the String.fromCharCode method to convert the decimal value to its corresponding ASCII character. The ASCII character is returned by the function.

const convertingAsciiToDecimal= ASCII => {
  let decimals = []
  for(let i = 0; i < ASCII.length; i++) {
     decimals.push(ASCII.charCodeAt(i))
  }
  return decimals
}

 convertingAsciiToDecimal('HELLO'))
=> [ 72, 69, 76, 76, 79 ]

The function creates an empty array called decimals then using a for loop, the function iterates over each character of the ASCII string, one at a time. For each character, the function calls the charCodeAt method, passing the index of the character in the string as an argument. This method returns the Unicode value of the character, which corresponds to the decimal value of the ASCII character. The decimal value is then added to the decimals array using the push method.

After iterating over all characters in the ASCII string, the function returns the decimals array, which contains the decimal values of each ASCII character in the original string.

Conclusion

In conclusion, conversion functions are crucial for converting between different data types and formats, including binary, hexadecimal, decimal, ASCII, and others. Being able to convert between these formats is essential for data manipulation, encoding, and decoding. Understanding how to use these conversion functions is fundamental for all developers and can improve their coding efficiency and versatility.

Creating demos for your web applications

Tatiana Bowman — Fri, 28 Apr 2023 15:57:13 +0000

Recording a demo for your application can be an effective way to showcase its features to recruiters and potential users. It'll help them better understand how your project works and what it can do. Highlighting the key features and giving visual representation can help you stand out and increase your chances of landing a job during your search.

Here are a few tips:

1. Create a script

creating a script or giving yourself guidelines to follow will make the recording process 10x's easier. I'll ensure that you cover everything that you want presented.

2. Opening

Make sure to introduce yourself before starting. Give a greeting, state your name, the name of the project as well as a brief description of what it is and why you chose it.

3. Demonstration

Make sure to speak clearly and at a steady pace, highlight each feature and if you want, include any stretch goals that you may have.

4. Closing

When wrapping up make sure to repeat your name and the name of the project as well as reiterating what the project does. Then end it by thanking the viewer for their time.

5. Keep it short

Try to keep your demo short, aim for a video that is no longer than five minutes long.

*Example: *

Opening

Hello! My name is [YOUR NAME HERE] and this project is called [PROJECT NAME HERE]! [A BRIEF DESCRIPTION OF THE WEBSITE].

Middle

*[HOW DID YOU COME UP WITH THIS IDEA?]
*

[ DEMO WEBSITE ]

Closing

In the future, I would really like to [STRETCH GOALS] But other than that that’s all I have!

again my name is [YOUR NAME HERE] and my project is called [NAME OF WEBSITE AND BRIEF DESCRIPTION]! And Thank you for your time!

6. Screen recording tool

Loom is a great tool for creating demos and is easy to use! You are able to download it on your computer as well as make it a Chrome extension for quick and easy access. It also allows you to trim and edit your videos if needed.

Conclusion

Recording demos for your projects can be an effective way to showcase your skills and help you stand out.

JavaScript Classes

Tatiana Bowman — Mon, 06 Mar 2023 14:15:54 +0000

What are classes?

Classes are a template for creating objects. They encapsulate data with code to work on that data. In JavaScript, classes are defined using the class keyword, followed by the name of the class, and a set of curly braces.

class Person {

}

note: Class names should always start with a capital letter

The class uses something called a constructor which is used for creating and initializing an object instance of that class.

class Person {
    constructor(name, age, occupation, hobbies = []) {

   }
}

note: the variables can take in default values as seen above for hobbies.

Within the constructor method, we use the this keyword, which references the newly created object instance.

class Person {
    constructor(name, age, occupation, hobbies = []) {
        this.name = name
        this.age = age
        this.occupation = occupation
        this.hobbies = hobbies
   }
}

To create an instance of a class we use the new keyword and the name of the class.

let tatiana = new Person(
    'Tatiana',
    21,
    'Software Engineer',
    [
        "Reading",
        "guitar",
        "working out",
        "movie theater rat"
    ]
)

And once you console log the new instance you should get:

Person {
  name: 'Tatiana',
  age: 21,
  occupation: 'Software Engineer',
  hobbies: [ 'Reading', 'guitar', 'working out', 'movie theater rat' ]
}

Class & Instance Methods

Classes also use something called methods which is a function that is part of the class and performs an action for it. In javascript we have something called instance methods and static methods. An instance method is a method that is typically invoked on a given instance of the class stored in a variable.

*Instance Method: *

aboutMe() {
    console.log(
        `My name is ${this.name} I'm ${this.age} years old, and I work as a ${this.occupation}!`
    )
   }

In this example, I created a sentence using the variables from the constructor.

Which in return should give you:

My name is Tatiana I'm 21 years old, and I work as a Software Engineer!

when you call the method on the class instance like so:

tatiana.aboutMe()

A static method is invoked directly on a class, not on the instance. And The syntax for a static method is the same as an instance except that their declarations start with the **static **keyword.

Static Method:

static getOccupations(...people) {
     return people.map(person => person.occupation)
   }

In this example, I'm using the static method to collect the occupation from each instance and return them in an array. You then use the static method by calling it on the class and passing in the instance methods.

let occupations = Person.getOccupations(tatiana, peachy)
console.log(occupations)

giving you:

[ 'Software Engineer', 'Cafe Owner' ]

Static Variables

Along with the static methods, there is also something called static variables. Static variables are declared like the **static **keyword, followed by the variable name and value.

static peopleCount = 0;

Here's a usage example:

class Person {
    constructor(name, age, occupation, hobbies = []) {
        this.name = name
        this.age = age
        this.occupation = occupation
        this.hobbies = hobbies

    Person.peopleCount += 1;
   }
static peopleCount = 0;
}

In this example, I'm using the static variable to keep track of the number of Person instances being made. I should get the output of 2 after using the variable on the Person class.

console.log(Person.peopleCount)

//output 

2

*Putting it all together: *

class Person {
    constructor(name, age, occupation, hobbies = []) {
        this.name = name
        this.age = age;
        this.occupation = occupation
        this.hobbies = hobbies

        Person.peopleCount += 1
   }

   static peopleCount = 0;

   aboutMe() {
    console.log(
        `My name is ${this.name} I'm ${this.age} years old, and I work as a ${this.occupation}!`
    )
   }

   static getOccupations(...people) {
     return people.map(person => person.occupation)
   }
}

let tatiana = new Person(
    'Tatiana',
    21,
    'Software Engineer',
    [
        "Reading",
        "guitar",
        "working out",
        "movie theater rat"
    ]
)

let peachy = new Person (
    "Peachy",
    "22",
    "Cafe Owner",
    [
        "Reading",
        "drums",
        "guitar",
        "roller skating"
    ]
)

// instance methods
tatiana.aboutMe()
peachy.aboutMe()


// static methods
let occupations = Person.getOccupations(tatiana, peachy)
console.log(occupations)

// static variable
console.log(Person.peopleCount)

Inheritance

Classes also have something called inheritance which allows the properties and methods defined on a parent class to be available for objects created from classes that inherit from those parent classes.

To implement inheritance we use the extends keyword to say that this class inherits from another class.

Example:

class Child extends Person {

}

*Super *

We then use something called the **super **keyword which is used to access properties on an object literal or class's Prototype, or invoke a superclass's constructor.

The super keyword may appear as a "function call", and must be called before the this keyword is used. It calls the parent class's constructor and binds the parent class's public fields, after which the derived class's constructor can further access and modify this.

Example:

class Child extends Person {
    constructor(firstName,age, occupation, hobbies, grade) {
    super(firstName, age, occupation, hobbies)
        this.grade = grade;
    }
}

let aisha  = new Child("A'isha", 9, "unemployed",["coloring", "dancing", "karate"], "5th" )
console.log(aisha)

giving us:

Child {
  firstName: "A'isha",
  age: 9,
  occupation: 'unemployed',
  hobbies: [ 'coloring', 'dancing', 'karate' ],
  grade: '5th'
}

note: make sure to add the super keyword, using inheritance w/o it will invoke a reference error.

ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor

Conclusion

Classes are a template for creating objects. They encapsulate data with code to work on that data. By using classes, you're ensuring that methods are only used on one set of data. Classes also provide an easy way of keeping the data members and methods together in one place which helps in keeping the program more organized.

Helpful Resources

https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/Classes_in_JavaScript

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/constructor

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this

Using A Helper Function

Tatiana Bowman — Mon, 13 Feb 2023 14:42:16 +0000

Using a helper function is pretty simple and it's a very useful tool that will help keep your code D.R.Y (Don't Repeat Yourself) and help you maintain the S.R.P (Single Responsibility Principle). Because of that it also makes our code easier to debug.

A helper function is a function that is called within another function, and we are able to use the return value from that function being called.

Example

In this example I'm going to show you how a helper function can be used:

function isPrime(number){
    if(number < 2) return false;

    for(let i = 2; i < number; i++) {
        if(number % i === 0) return false;
    }
    return true;
}


function collectPrimes(numbers){
    let primes = []
    for(let i = 0; i < numbers.length; i++) {
        let number = numbers[i]
        if(isPrime(number)) primes.push(number)
    }
    return primes;
}

The goal was to create a function that filtered out only the prime numbers and returned them in a new array. In order to do that and maintain the S.R.P, I had to break down the problem into two.

The Breakdown

function isPrime(number){
    if(number < 2) return false;

    for(let i = 2; i < number; i++) {
        if(number % i === 0) return false;
    }
    return true;
}

The isPrime (helper function) is taking in each number that is being sent up from collectPrimes (by calling it in the function and passing in the numbers) and checking if it is a prime number. If it is it will return true if not it will return false.

function collectPrimes(numbers){
    let primes = []
    for(let i = 0; i < numbers.length; i++) {
        let number = numbers[i]
        if(isPrime(number)) primes.push(number)
    }
    return primes;
}

Once it gets back down to the collectPrimes function the conditional checks if we got a truthy value back from the isPrime function, then it pushes that prime into the primes array and returns a new array of primes.

side note: We could also refactor this code and make it cleaner by using the .filter method, which will iterate through. filter out the primes, and return a new array of only the prime numbers.

return numbers.filter(number => isPrime(number))

(If you are not familiar with array iteration methods like .filter check out my previous blog post called The Fantastic Four: .map, .filter, .forEach, & .reduce array (iteration) methods).

Other Helpful Resources

What are Helper Functions, How to Use a Helper Function in JavaScript, Programming with Codecademy

What are the Helper functions ?

The Fantastic Four: .map, .filter, .forEach, & .reduce array (iteration) methods

Tatiana Bowman — Mon, 23 Jan 2023 15:01:21 +0000

An array (iteration) method is a function built into JavaScript that we use to apply to arrays. There are a few other great array methods but these particular four are always good to know and come in handy when needed.

These methods take in four parameters:

1.) A callback function to execute for each element in the array. Its return value is added as a single element in the new array.

2.) The element being processed in the array.

3.) Index of the current element being processed in the array.

4.) The array the method was called upon.

so it ends up looking something like:

array.arrayMethod(element, index, array) {
// action
}

The array method .Map() creates a shallow copy of the original array populated with the results of calling a provided function on every element in the calling array. The result of the passed-in callback will be a new array with each element.

For example say I want a new array with every element multiplied by two:

function double(numbers) {
    const doubled = numbers.map((number, i ,array) => {
        return number * 2;
    })
    return doubled;
}

double(numbers)

In the above example, I created a function that takes in an array of numbers

const numbers = [1, 2, 3, 4, 5];

and using the map method it iterated over the array multiplying each number by two adding it to an array and returning in the place of the old one getting us this result:

//  [1, 2, 3, 4, 5] =>  [ 2, 4, 6, 8, 10 ]

side note:
We can make this code so much cleaner! Because I'm not using the index or the array we can take those out of the parameter and just leave the element without the extra parentheses. We can also get rid of the variable that's holding the map function, the returns, and the curly braces so the whole inner function can just fit on one line of code like this:

return numbers.map(number =>  number * 2);

Next up we have the .filter() which just like .Map() returns an array of elements. It creates a shallow copy of a portion of a given array, filtered down to just the elements from the given array that pass the test implemented by the provided function.

for example, say I wanted an array of only the even numbers:

function onlyEvens(numbers) {
 const evens = numbers.filter((even, i, array) => {
    return even % 2 === 0;
 })
 return evens;
}

onlyEvens(numbers)

By using the filter method I was able to "filter" out any number that is % 2 === 0 thus giving me all the even numbers in a new array.

here's a cleaner look:

return numbers.filter(even => even % 2 === 0)

And here's another example not involving math:

function fiveAndBelow(words) {
    return words.filter(word => word.length <= 5 )
}

fiveAndBelow(["lala", "land", "I", "independent", "cakey", "developer"])

["lala", "land", "I", "independent", "cakey", "developer"] => [ 'lala', 'land', 'I', 'cakey' ]

Next we have the .forEach() method which executes a provided function once for each array element callbackFn will not visit any elements added beyond the array's initial length when the call to .forEach() began._ (it's basically a for loop but less work)_

for example, say you want to print out each element in an array:

function print(words) {
    return words.forEach(word => console.log(word))
}

print(["lala", "land", "I", "independent", "cakey", "developer"])

*prints*
lala
land
I
independent
cakey
developer

The .forEach() method iterated over the array and returned a console log of each element.

Another example, say you want the total sum of an array of numbers:

function findSum(numbers) {
    let sum = 0
    numbers.forEach(number => sum += number)
    return sum;
}

The method iterated over the array adding each element to the sum value giving us the overall sum of the array once returned.

But of course for anything math-related like finding the total sum of an array you can also use .reduce() method.

Speaking of .reduce() method it executes a user-supplied "reducer" callback function on each element of the array, in order, passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the array is a single value.

unlike the other three reduce needs two more parameters the accumulator and initial value. The accumulator which is the value resulting from the previous call to callbackFn. On first call, initial value if specified, otherwise the value of array[0].

(So if you think back to the forEach method the initial value is basically the let sum = 0, and if you don't set one it will just latch on to the first index in the array and use that.)

for example, say you want the total product of an array of numbers:

function findProduct(numbers) {
    return numbers.reduce((accum, num) => accum *= num, 1)
}

The accumulator is holding on to that initial value iterating over the array and multiplying the elements together.

side note:
You can also one-line this whole function creating less and cleaner code by using a function expression instead of a function declaration:

const findProduct = numbers => numbers.reduce((accum, num) => accum *= num, 1)

In conclusion, although they might not be everyone's top choice the map, filter, forEach, and reduce methods are great tools to know and will always come in handy when needed.

Resources:
Array Methods:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array

https://www.geeksforgeeks.org/javascript-array-iteration-methods/

https://youtu.be/Urwzk6ILvPQ

Arrow functions:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions

https://youtu.be/h33Srr5J9nY

Function Expression:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function

https://youtu.be/37ly8tCGFWA

If you can use a while loop you can use recursion (coming from a ex recursion hater)

Tatiana Bowman — Fri, 23 Dec 2022 15:01:37 +0000

I bet you've heard the phrase "If you can do it recursively you can do it iteratively" true but that still didn't make me hate it any less when I first started learning it. Recursion was a huge pain but once you get the pattern down even a little it's easier and becomes a very useful tool. One thing that helped me was realizing that while loops (which I love) and recursion are basically the same thing just slightly different code.

What is recursion?

Recursion is the act of a function calling itself within itself. When solving with recursion you need two things 1. a base case which is used as a sort of stopper for the function and 2. a recursive call which is the act of the function calling itself.

In the example above I started with a base case that states if the number is less than or equal to zero print "Happy New Year", so when the number gets down to zero it will print the message.

The way to get it to zero is through the recursive call on line 9, as you can see every time I call the function it decrements the number by one getting it closer and closer to the base case.

So you call the function it takes the number and checks if it's equal to zero if it isn't it'll print, decrement by one then get called again but as a smaller number each time.

What is a while loop?

**
A while loop creates a loop that executes a statement as long as the condition evaluates to true. A while loop can be used just like a for loop, having the exact same syntax but it can also be used like recursion.

In the above example, I started with a condition that states while the num is more than 0, print the num then decrements so once it hits 0 it'll break out of the loop and print "Happy New Year!!".

As you can see the base case of the recursive solution and the while loop condition are basically the same the only difference is the way it's stated. The base case says "if the number is less than or equal to zero". And the while loop says " While the number is more than zero". Both need to hit zero in order for the breakout and both have to decrease the number to get there.

side by side:

Here's a more complex example of how they can be used w/ pseudo code to help break it down:

Conclusion

I hope this comparison helped to give you a better understanding of recursion and how it can be used. Recursion is tricky to learn but it can allow you to break down big problems into smaller ones, and can sometimes even produce simpler solutions. If it helps try and think of it like a yoyo.

Because this post is more of a comparison of while loops and recursion than explaining recursion, If you want to learn more about it here are a few links that really helped me:

What is recursion - In Depth
https://youtu.be/6oDQaB2one8

Recursion Crash Course:
https://youtu.be/lMBVwYrmFZQ

Stepping through recursion Fibonacci function:
https://www.youtube.com/watch?v=zg-ddPbzcKM

(P.S. I still kinda hate it!)

DEV Community: Tatiana Bowman

Conversion Functions: converting between binary, hexadecimal, decimal, & ASCII

What are binary, hexadecimal, decimal, & ascii?

Built-in functions: parseInt(), toString(), charCodeAt(), String.fromCharCode(), and substring()

Conversion Function Examples & Breakdowns

Conclusion

Creating demos for your web applications

Here are a few tips:

Conclusion

JavaScript Classes

What are classes?

Class & Instance Methods

Inheritance

Conclusion

Helpful Resources

Using A Helper Function

Example

The Breakdown

Other Helpful Resources

The Fantastic Four: .map, .filter, .forEach, & .reduce array (iteration) methods

If you can use a while loop you can use recursion (coming from a ex recursion hater)

*What is recursion? *

What is a while loop?

side by side:

Here's a more complex example of how they can be used w/ pseudo code to help break it down:

Conclusion

What is recursion?