Forem: Lukas Mills

Basics of Binary Code in Computer Science

Lukas Mills — Tue, 04 Oct 2022 15:16:24 +0000

What is Binary Code?

For humans, we are able to communicate with one another through our wide range of 7,000+ languages in the world, but the way in which computers communicate to one another is through Binary Code. Any time you go to watch a movie, listen to music, or look up directions, you are giving your device input, and it turns into Binary Code. Binary Code is made up of 2 digits 0's, and 1's, unlike our traditional decimal system that is made up of 10 digits. The 0's and 1's are how computers read, process, and store data. These 0's and 1's can represent any symbol, letter, number, or segment of data. Binary Code can also be broken down further into what is called and Byte, and a Bit.

Bit

John Tukey, a leading statistician and adviser to five presidents first coined the term in 1946. A single bit is made up of a single 1 or 0. Computers are often classified by the number of bits they can process at one time. Graphics are often described by the number of bits used to represent each pixel, and a certain number of bytes makes up a larger unit called a KiloByte, MegaByte, GigaByte, or a TeraByte.

Byte

A byte is a unit of storage capable of holding a single character for example those letters, numbers, and symbols, we talked about earlier. One byte is equal to 8 bits (a single 1 or 0)

Byte: This is a single byte composed of 8 bits => 01100011 = "c"

Now what if we wanted to used multiple bytes to compose a word or sentence?

The Alphabet Using Binary

A word using Binary

Finally A Sentence Using Binary

This gets very long winded, because a single byte doesn't represent one word, it only represents a single character, which is why us humans don't use this as a form of language, but this binary system is what computers use everyday to communicate!

Imposter Syndrome In Software Engineering

Lukas Mills — Thu, 15 Sep 2022 12:02:36 +0000

Imposter Syndrome is something that the majority of us have dealt with at one point or another, and if you haven't dealt with this yet you're bound to have this feeling at one point or another.

Causes

Imposter Syndrome is very relevant and real in any field of study, but to me at least I feel as though it is more relevant in any type of tech related field especially Software Engineering. One of the main causes Engineers feel this way is because Software Engineering is a fast moving industry, with brand new technologies introduced every day, it is physically and mentally impossible to learn every single framework or language there is out there. Another reason imposter syndrome is so relevant today in Software Engineering is because there is a misconception in this industry that you have to be super smart, like Steve Jobs, Bill Gates, or Elon Musk kind of smart, but you don't have to be that at all.

Managing Imposter Syndrome

If you came here looking for a fix for imposter syndrome I am afraid I cannot give that answer to you, because it is something that will always stick with you. There is always going to be someone smarter than you no matter what, unless you are the upper echelon of Engineers. One of the most important things to remember, as Software Engineers it isn't always important to know the most things or be the smartest in the room, it's easier and much more important in our industry to have the ability to learn a new language or framework very quickly, and to have very good problem solving skills.

The Basics of Building a Functional API Using Active Record and Sinatra

Lukas Mills — Thu, 25 Aug 2022 16:06:00 +0000

Quite often when building projects during Phase 1 and Phase 2 I ran into a lot of API issues where not a single API that I could find had all of the correct data that I wanted to use for my website. Now, that I have learned Sinatra, and Active Record I can build my own API so I can have all of the data I've ever dreamed of using. Hopefully, after you're done reading this you'll be able to build your own API as well!

Starter Code:

To get started building your own API let's first get some starter code! Fork and clone this down to your machine. https://github.com/learn-co-curriculum/phase-3-sinatra-react-project

For this example today we will be building an API for a movie review website!

Bundle Install

Open up and new terminal and type this into your console:

bundle install

What this does is it installs every single Gem in our Gemfile to help us create our API. Some of the more important Gem's include: sinatra, rake, sqlite3, faker, and activerecord-reset-pk-sequence.

Creating our Models

Go into your App >> Models folder, and create new files called movie.rb, review.rb, and user.rb. Creating our models not only gives us the opportunity to create customs methods to do whatever we want with our data, but it allows us to get proper associations (relationships) which will play a vital role in building our database.

After you have created our models, let's give them some class names!

movie.rb:

class Movie < ActiveRecord::Base

end

review.rb:

class Review < ActiveRecord::Base

end

user.rb:

class User < ActiveRecord::Base

end

You might be wondering what does "ActiveRecord::Base" do? This essentially provide an interface and binding between the tables in our relational database and the Ruby program code that manipulates database record.

Giving Our Models Associations With One Another:

Before we jump into the code it's important to think about our domain model. A domain model is essentially, for a lack of a better term a way of "whiteboarding" our associations between models.

Our domain model: movie —--<reviews>-------user
Looking at our domain model we can begin to think about their associations between one another in pseudocode.
A movie has many reviews
A movie has many users, through reviews
A user has many reviews
A user has many movies, through reviews
A review belongs to a movie
A review belongs to a user

Now let's jump into our code and let's start creating those associations!

movie.rb:

class Movie < ActiveRecord::Base
    has_many :reviews
    has_many :users, through: :reviews
end

user.rb:

class User < ActiveRecord::Base
    has_many :reviews
    has_many :movies, through: :reviews
end

review.rb:

class Review < ActiveRecord::Base
    belongs_to :movie
    belongs_to :user 
end

If you haven't been able to tell already, we just put into our code what we wrote out in pseudocode, just with some syntax!

Creating migrations:

The next step of our journey is creating our migrations! Migrations give us a way of essentially creating columns and keys in our database!

Open up a new terminal and type these lines in one at a time and hit enter!

rake db:create_migration NAME="create_movies"

rake db:create_migration NAME="create_users"

rake db:create_migration NAME="create_reviews"

After you've created these migrations go into your db >> migrate folder and you should see something similar to what I have:

Great! We've created these migrations for our tables, but how do we create new columns for our table?

create_movies.rb:

class CreateMovies < ActiveRecord::Migration[6.1]
  def change
    create_table :movies do |t|
      t.string :title
      t.string :image
      t.integer :release_date
      t.string :genre
    end
  end
end

WOAH! That's a lot of information to take in let's break it down step by step:
class CreateMovies: Gives us a class name of our migration
ActiveRecord::Migration[6.1]: Some rake magic that allows us to create migrations for our tables.
def change: Creating a method
create_table :movies: Creates a table with the name of movies.
t.string: Allows us to apply a datatype to the column we are creating.
:title: Creates a name for our data that we want represented in our table or frontend. Here so one of our movie titles will be: 'Interstellar'

Now let's go ahead and create every migration for each model:

create_users.rb:

class CreateUsers < ActiveRecord::Migration[6.1]
  def change
    create_table :users do |t|
      t.string :name
    end
  end
end

create_reviews.rb:

class CreateReviews < ActiveRecord::Migration[6.1]
  def change
    create_table :reviews do |t|
      t.integer :movie_id
      t.integer :user_id
      t.string :comment
      t.integer :rating

    end
  end
end

Looking at our create_reviews.rb migration can you tell what the difference is?

When we refer back to our domain model and our pseudocode movie —--<reviews>-------user we can see that our reviews belong to a movie and a user. By creating columns for our movie_id and our user_id we are putting in the final puzzle piece to create associations between our models.

After creating our migrations let's actually migrate them to our database!

In your terminal type this:

rake db:migrate

Great we have our columns appropriately applied to our tables, but now how can we add data to them?

Seeding our data:

For our API to display any information we have to give it some type of value, one of the easiest ways to do this is to seed our data! Looking at our file directory we will see a starter seeds.rb file.

Once you are in there let's create our very first movie!

m1 = Movie.create( 
    title: 'Harry Potter and the Goblet of Fire',
    image: 'https://m.media-amazon.com/images/I/71opdcUCGjL.jpg',
    release_date: 2005,
    genre: 'Fantasy'
)

Looking at this, you can already get a sense of what is going on here! We are creating an instance of a movie and giving our keys like title and image some value in our database! But what about users, and reviews?

Faker:

In this case, Faker is a ruby gem that allows us to randomly generate names for our Users so we don't have to continuously have to create new instances of our Users ourselves.

Users:

5.times do 
    User.create(name: Faker::Name.name)

This is creating 5 Users, and each giving them a randomly generate name!

Reviews:

r1 = Review.create(comment:"I liked this film very much. It is much darker than the previous outings, but not as faithful to the source material. The only thing I didn't like so much about the book, was the subplot about Hermione trying to help house elves. It was cute, but interfered too much with the dark overtones of the narratives. The film looks dazzling, especially the ballroom scene. Speaking of that scene, I adored that dress that Hermione was wearing, Emma Watson looked unrecognisable in that scene.Also the music by Patrick Doyle this time was beautiful." , rating: 5 , user_id: User.ids.sample , movie_id: m1.id)

Unfortunately for us there isn't a Faker for creating reviews, so we must hard code our own reviews!

After you have done all of the steps go into your terminal and type in
rake db:seed
We now have all of the essential data to fetch on the frontend! But how are we able to tie in this data and use a fetch call to display it on the front end?

Controllers

Controllers act as a middle man that allows us to create custom routes when fetching on the frontend.

The first step we must do is go into our app >> controllers >> application_controller.rb file and create a class that inherits Sinatra.

class ApplicationController < Sinatra::Base
set :default_content_type, 'application/json'

end

Now let's create our custom routes for the data we want displayed!

get "/movies" do
    movies = Movie.all
    movies.to_json
  end

Now what does all of this do?

/:specifies the route path we want to create.
movies = Movie.all: creates a variable holding all of our Movie data.
movies.to_json: Converts all of the data we have on movies to json.

Now what if we wanted to include our users and our reviews with our movies?

get "/movies" do
    movies = Movie.all
    movies.to_json(include: { reviews: {include: :user} }) 
  end

Now if you start your rake server in your terminal with rake server and type http://localhost:9292/movies in your browser, you should we something similar to what I have!

You have just built your first local API! Congragulations!

React Hooks For Beginners : useState

Lukas Mills — Mon, 01 Aug 2022 15:52:00 +0000

The useState hook allows us to create state variables in a React function component, also useState allows us to access and update certain values in our components over time. Finally, whenever we do create our useState hook we must give it a default value, and this can be any data type.

Before we start working with useState we must import it from React.

Example:

import { useState } from 'react'

And just like that you have access to all of the wonderful things that useState has to offer. But now what if we wanted to use our useState hook in a real world scenario?

Example:

import { useState } from 'react'

function favoriteAvengers() {

const [avenger, setAvenger] = useState('Spider-man')

// avenger: a variable that stores the current value of our favorite avenger 'Spider-man'
// setAvenger: allows us to update or change the value of our avenger variable over time.
// useState('Spider-man'): is our default value of our variable 'avenger'

Now let's add a button that changes our state to a different avenger when it's clicked:

import { useState } from 'react'

function favoriteAvengers() {

const [avenger, setAvenger] = useState('Spider-man')

return (

<h1>My favorite Avenger is {avenger}!</h1>

<button
type ='button'
onClick={() => setAvenger('Thor')}
>Change Avenger</button>
)}

Now this is just the tip of the iceberg on what you can do with state, but this gives you a basic and fundamental understanding of how useState works!

Basic Array Methods

Lukas Mills — Wed, 13 Jul 2022 03:11:34 +0000

I have always had interest in data structures ever since I started going to school for Computer Science, but one thing that I could never remember were array methods. Hopefully, you're like me and want to refer back to simple documentation explaining how array methods work!

1. shift()

The shift method allows us, as the user to remove the first element from an array, returns the first element and modifies the original array.

let videoGames = ['Minecraft', 'Among Us', 'Valorant', 'GTA']
videoGames.shift() // returns Minecraft
console.log(videoGames) // ['Among Us', 'Valorant', 'GTA']

2. pop()

The pop method acts in the same way as shift, the only difference being is that it removes the last element of any array.

let sports = ['basketball', 'baseball', 'football', 'soccer']
sports.pop() //returns soccer
console.log(sports) // ['basketball', 'baseball', 'football']

3. splice()

The splice method has the ability to add or remove elements from an array. The first argument is the index location where the elements are to be removed or added. The second argument is the number of elements that you want to remove from the array.

let avengers = ['Hawkeye', 'Thor', 'Spider-Man', 'Hulk', 'Iron Man', 'Captain America']
avengers.splice(1,3) // returns ['Thor', 'Spider-Man', 'Hulk']
console.log(avengers) // ['Hawkeye', 'Iron Man', 'Captain America']

Now if we wanted to remove an index, and add a different value you it would look like this.

let avengers = ['Hawkeye', 'Thor', 'Spider-Man', 'Hulk', 'Iron Man', 'Captain America']
avengers.splice(1,1, 'Ant-Man') // returns Thor and replaces Thor with Ant-Man
console.log(avengers) // ['Hawkeye', 'Ant-Man', 'Spider-Man', 'Hulk', 'Iron Man', 'Captain America']

4.) slice()

This slice method is used to remove elements from an array without modifying the original array. Also with this method, with what elements you do remove a brand new array is created with those elements. When specifying the range of elements that you want to remove just like our other methods you first want to define was element you want to start with, and the second argument is what you want to end with (the ending index is not included in the new array).

let codeLanguages = ['Python', 'JavaScript', 'Java', 'TypeScript', C++]
codLanguages.slice(1,3) // returns ['JavaScript', 'Java'] and creates a new array
console.log(codeLanguages) // ['Python', 'JavaScript', 'Java', 'TypeScript', C++]