Forem: Alyssa Falcione

Active Record - The M in MVC

Alyssa Falcione — Sat, 25 Feb 2023 22:19:59 +0000

Websites have come a long way in the last 30 years and the MVC framework has aided greatly in that. Remember older static websites with very limited, if any user interaction? I may be showing my age here, but this specific website comes to mind that CNN posted on their main page from the 1996 trial for the Orenthal James Simpson, also known as OJ Simpson:

http://www.cnn.com/US/OJ/

As you can see, it is VERY simple, and not attractive at all. This came from CNN. This just goes to show how far we have come in the world of computer science. Websites have been able to shift from using simple HTML and CSS to many other frameworks that help us to create more interactive and useful websites for our users.

What is the MVC?

The Model-View-Controller is a software design pattern that software developers use to keep their code organized into three main logical components. Each component has their own role to play, which makes sense in the real world also. In a restaurant, the chef cooks the food, the server serves it, and the bartender tends bar. With everyone having their own distinct roles, things can run more smoothly and organized.

The Model:

Being in charge of all data-related logic, we can compare our Model to a Chef in a restaurant. The Chef receives the food order from the Controller (our waiter in this analogy), which our waiter received from the View (our food menu). Therefore our Chef (or Model) now has the knowledge to execute our meal. So when you think of Model, think of data-related logic.

The View:

Alright lets talk about our food menu, the View. This component of our architectural software pattern is what serves the User information they need to order a delicious meal. Being in charge of the layout and display, the view can be thought of as the frontend, or graphical user interface.

The Controller:

Our Waiter or Waitress is our Controller. This is how our Customer or User can interact with our Chef, or Model. Our middleman per se. Our Controller will collect the data and deliver it to our Model, so our Model can begin preparing our meal.

Okay, now that we know the basics of the MVC architecture, let's talk about how Active Record comes into the equation.

Rails Active Record

Rails Active Record provides an interface and binds tables in relational databases. For instance, when we think of classes with Active Record, we think of tables. Just as rows map to objects and columns map to object attributes. Every Active Record object has CRUD capabilities and methods for database access. This is known as Object Relational Mapping, which is a technique that connects the objects of an application to tables in a relational database system.

There are many benefits of using Active Record, it gives us the ability to add validations before our data is persisted to the database. It also allows us to represent associations between models and to develop inheritance hierarchies through related models.

Active Record vs SQL

When working with databases, we often have to make queries. Active Record makes this process simple for programmers. Let's compare some queries in SQL vs Active Record.

Finding Objects in SQL:

SELECT * FROM customers WHERE (customers.first_name = 'Andy') LIMIT 1

Finding Objects in Active Record:

 Customer.find_or_create_by(first_name: 'Andy')

As you can see, it takes less code using Active Record and is easier for the human mind to interpret.

Say we want to find the first existing record:

SQL:

SELECT * FROM customers ORDER BY customers.id ASC LIMIT 1

Active Record:

customer = Customer.first

And the last,

SQL:

SELECT * FROM customers ORDER BY customers.id DESC LIMIT 1

Active Record:

customer = Customer.last

Active record also has a where method that allows us to make more specific queries:

Customer.where(first_name: 'Lifo')

vs SQL:

SELECT * FROM customers WHERE (customers.first_name = 'Lifo') LIMIT 1

As you can see, Active Record insulates developers from having the need to use SQL in most cases and gives us the syntactical sugar that all programmers dream of, giving us cleaner, and more readable code.

Let's look at how we can order our Objects in both Active Record and SQL:

Active Record:

Book.order(:title, created_at: :desc)

SQL:

 Book.order("title ASC").order("created_at DESC")

We can also join associations with Active Record queries:

Active Record:

Book.joins(:reviews)

SQL:

SELECT books.* FROM books
  INNER JOIN reviews ON reviews.book_id = books.id

Now that is a significantly less code using Active Record. Now you can see why Rails developers love Active Record so much, it saves us time, has less keystrokes and helps to enhance security in our applications.

Error Handling with Ruby on Rails

Alyssa Falcione — Tue, 10 Jan 2023 17:53:17 +0000

Naturally when we encounter an error in our code, Ruby will crash our program. Ruby on Rails with Active Record has developed a way to combat this so that developers can debug their code easier.

Exceptions

We all need rescued sometimes, Active Record is here at our aid with the help of raising exceptions for error handling. Exceptions in Ruby on Rails using Active Record gives developers a way to deal with unexpected events, or errors. So when we encounter an error, rather than crashing the whole program, we can use built in exceptions which will halt the program and help us to handle any errors that are thrown.

Rescue_from

Since all of our controllers inherit from our application controller in Ruby on Rails, that is where we will put our logic to handle our exceptions:

class ApplicationController < ActionController::API

rescue_from ActiveRecord::RecordInvalid, with: :unprocessable_entity_resp

rescue_from ActiveRecord::RecordNotFound, with: :not_found_resp

before_action :authorize

def current_owner
  @current_owner ||= Owner.find_by(id: session[:owner_id])    
end  

private 

def unprocessable_entity_resp(invalid)
  render json: {errors: invalid.record.errors.full_messages}, status: :unprocessable_entity
end

def not_found_resp  
  render json: {errors: "Not Found"}, status: :not_found
end

def authorize 
  render json: {errors:{Owner: "Not Authorized"}}, status: :unauthorized unless current_owner
end

As you can see in the code above, we use the "rescue_from" exception at the top level of our controller which is inherited from Active Record. The "with:" refers to a method that we create to handle the exceptions and to log our error messages. In the code above, the RecordNotFound exception is handled using our :not_found_resp method. Within that method we render our error message with JSON and provide that status of "not found".

So to break this down in shorter terms, when you try to access data that cannot be found, Active Record will raise an exception and handle our errors with our "not_found_resp".

There is a second important key to this. Adding the exceptions to the methods we would like to apply it to.

Class OwnersController < ApplicationController

    skip_before_action :authorize, only: :create

    def create
        owner= Owner.create!(owner_params)
        session[:owner_id] = owner.id
        render json: owner, status: :created
    end 

    def show
        render json: @current_owner, status: :ok
    end

    private

    def owner_params
        params.require(:owner).permit( :username, :password)
    end
end

In the Owners controller above, if you look at our "create" method you will notice the "!" after create. This is what allows us to raise an exception on this method. So if an error is encountered in this method, Active Record will refer back to our application controller and hit the method we created to handle the error it pertains to. Pretty easy, right?!

Error Handling with Post Requests to our Front

Here I would like to discuss a bit about how our frontend
(React) interacts with our backend (Ruby Rails) for error handling. Specifically with a POST request.

Let's say that we have an application that allows users to login. This would be a post request since we are sending data to our backend. We can handle this by using a fetch request that goes to a specified endpoint.

 const [errors, setErrors] = useState([])

 fetch('/api/login', {
      method: 'POST',
      headers: {
        "Content-Type": "application/json",
        "Accept": "application/json"
      },
      body: JSON.stringify(owner)
    }) 
    .then(res => {
      if(res.ok){
          res.json().then(owner => {
              loginUser(owner)
          })
      }else {
        res.json().then(json => setErrors(json.errors))
      }
  })

Our fetch request will go to '/api/login', and if everything goes well, it will send our owners information to our backend within our body and log our user in. However we all know that's not always the case. So what happens if we encounter an error?

Well, luckily we have implemented error handling in our backend to help with this. In the else statement from our React code above, you can see that we are taking the JSON response from our backend and setting it to our state so that we can access the errors from our backend, on our frontend.

Below you can see that we are printing our errors in our return in a

tag. So when an error occurs, it will print out that specific error to our user.

return (

{errors}

Log In

Username:

Password:

)
}

As you can see, error handling in Ruby on Rails with Active Record is quite simple and elegant.

I hope this blog was helpful and can assist you in error handling for your future Ruby on Rails projects.

Debugging common errors when coding in Ruby on rails

Alyssa Falcione — Thu, 29 Dec 2022 03:29:14 +0000

Debugging is a large part of being a software engineer, and it may be one of the more frustrating aspects of our job. But worry no more! I have put together this short blog on common errors you may encounter while coding in Ruby on rails, and how to debug them.

Let's first talk about the "puts debugging" technique first. Puts in Ruby on Rails can be used for many instances in debugging, but one of the more common use cases would be to find the value of a variable. Let's take a look at the example below:

puts variableValue

The puts statement above will give us the value of variableValue. However, it may not tell us everything we may need to know, so there are a number of variations we can use to help us gain more information about variableValue. Such as:

puts variableValue.class  <-Will tell us what type of object we have

puts variableValue.inspect <-Will return a string representation of the object

So therefore, "Puts" can aid us in debugging by evaluating the values of variables.

ActionController::RoutingError*

Routing errors are one of the more common errors you may run into. This happens when a URL has been requested that does not exist.

ActionController::RoutingError (No route matches [GET]"/flatIron"):

When encountering this error, the first thing you should examine would be your routes.rb file to ensure that your route exists. If that is set up correctly, your error could likely be found in the associated controller dealing with the "Show" method.

NoMethodError: undefined method

NoMethodError: undefined method `your_method`

This error can happen for a few different reasons. One of the more common reasons would be due to trying to call a method on an object that doesn't exist or Ruby is unable to find. You can usually resolve this error by checking your controllers to be sure that 'your_method' exists and is set up properly.

NoMethodError: undefined method for nil:NilClass

This error usually occurs when you pass an unexpected input to a class or method. You could also be receiving this error for trying to call on an object that has not yet been defined. Be sure to examine your methods to ensure the method and/ or associated object has been declared.

Unpermitted parameter:

Luckily with Rails 7, it now helps to provide context when we receive the "unpermitted parameter" error. Previous versions of Rails would not directly tell us the associated controller that the error is causing, but we now have that magic to make our lives easier. So when you see this error, head to your targeted controller to be sure that you passed all of permitted parameters properly. It is also important to check your schema to be sure that your table also has those a column associated with the parameter that is erroring out.

create_table "users", force: :cascade do |t|
    t.string   "firstname"
    t.string   "lastname"
    t.string   "email"
    t.datetime "created_at",      null: false
    t.datetime "updated_at",      null: false
    t.string   "password_digest"
    t.string   "password"
  end

If necessary, create a migration to update your table:

$ bin/rails generate migration AddColumnToTable

Then head to your migrations and add the column:

class AddColumnToTable < ActiveRecord::Migration[7.0]
  def change
   add_column :tableName, :columnName, :dateType
  end
end

Be sure to run "db:migrate" in your terminal to update your schema after updating your migration.

*Lastly lets talk about CORS Policy *

One of the more frustrating errors I encountered as a beginner working with Ruby on Rails was the "Cross-Origin Request Blocked" error, which was mainly due to inexperience. Most often times to solve this you just need to add the ruby gem 'rack-cors' to your gemfile and be sure to run 'bundle install' after. You also want to be sure to add the proper configuration to your application.rb file, it should look like this:

  class Application < Rails::Application

    # ...

    config.middleware.insert_before 0, "Rack::Cors" do
      allow do
        origins '*'
        resource '*', :headers => :any, :methods => [:get, :post, :options]
      end
    end
  end
end

Lastly, be sure to also add the configuration to your config.ru file:

require 'rack/cors'
use Rack::Cors do

 # allow all origins in development
 allow do
   origins '*'
   resource '*',
       :headers => :any,
       :methods => [:get, :post, :delete, :put, :options]
 end
end

Some words of encouragement

During my project build for FlatIron Phase 4, I encountered every single one of these errors and learned a lot from debugging each and everyone of them. It is easy to become overwhelmed and frustrated when debugging errors in our code, but we must remember that it helps to give us the skills and experience to be more efficient in our coding in the future. Learning from our mistakes is a big part of being a Software Engineer so embrace the errors and see it as a learning experience. I hope that this blog is able to help beginners become more familiar with common Ruby errors and how to handle them with a positive outlook.

Ohhh, CRUD!

Alyssa Falcione — Fri, 14 Oct 2022 21:44:59 +0000

Who doesn't love an acronym? We use them in all facets of life.. The medical field, computer science, and also as a form of communication, iykyk.

So let's talk about the important acronym at hand here. CRUD. Create. Read. Update. Destroy (or Delete). I personally prefer the term Destroy over Delete because it makes me feel like a powerful video game boss. I imagine my boss name would be something along the lines of "Doctor Bot", short for "Doctor Botany". I would use the plants of the earth to attack my opponents! Okay, enough nerdy stuff...

Back to CRUD! While there are other variations of CRUD such as ABCD, DAVE and CRAP, we are just gonna focus on CRUD for this blog article. In computer programming, CRUD can be used to describe a few different operations but we are going to set our sights on CRUD and the major operations it has with databases.

Sometimes CRUD can be referred to as a Data Manipulation Language (DML) because it is used to handle data inside of database tables. For example, using CRUD operations, we are able to manipulate data within database tables, whether it be to update data, delete it or create new data.

We use CRUD in everyday life as web surfers and don't even think about it. When you click on someones profile on facebook, you are performing the R (read) in CRUD. When you make a post, you are using the C (create) in CRUD, and so on!

CRUD and SQL

SQL is an acronym that stands for Structured Query Language, which is also a Data Manipulation Language. We use SQL to communicate with databases. SQL is a specialized language that allows users to request information, update information and even delete information if needed. Doesn't this sound awfully familiar to something? Hmm, wait... could it be... CRUD?!

You're on the right track! Each letter of the acronym for CRUD is related to a SQL statement. For example, Create is equivalent to Insert in SQL. Below is a table to show their relationship:

Create

Starting with the C in our acronym, Create! AKA insert or add, Create allows users to create new records in a database. Such as when we are creating a new post on instagram, we are performing a CRUD operation. Here is an example of what that code may look like in SQL with an already existing table:

INSERT INTO table_name (column1, column2)
VALUES (value1, value2);

The code above is specifying both column names and the values to be inserted. You can also write your INSERT statement without specifying column names if you are adding values for all existing columns.

Read

The read operation in CRUD, AKA select, can be thought of as a search function. It allows users to specify what data they want to access and retrieves that information for us. For example, when looking up someone's profile on LinkedIn, that is a read operation in CRUD. The code is quite simple for a select statement, as seen below:

SELECT * FROM menu;

This will display all items from the menu table. If we wanted to be more specific of the data we want to retrieve, we can add further parameters if they exist:

SELECT dinnerItems FROM menu.

When using the read operation, it will not alter any of our data, it only allows us to access it.

Update

The update operation in CRUD, AKA edit, allows us to alter or update existing data. Such as when we edit a post we have already made on Facebook, that would be our U (update) in CRUD. Here is an example below:

UPDATE table_name
 SET column1 = value1, column2 = value2, ...
 WHERE condition;

As you can see above, it is important that we specify the table name that we would like to update as well as the columns we will be making those changes to. It is also important that we add the associated values to be changed.

Destroy

Our lasts of CRUD, Destroy. AKA Delete. Delete is used to completely remove or destroy a record from a table. What is special about SQL is that it allows us to delete more than one record from a database at a time, pretty cool, right?! Below is an example of how we would perform a delete request:

DELETE FROM table_name WHERE condition;

Why is CRUD important?

CRUD is used in many types of applications, SQL is just one of many that utilizes these operations. We use CRUD for many things, including: security control, access and permission, performance optimization, etc. Without CRUD, software engineers would never get anything done. Imagine the internet without it - It would be awfully boring and some would argue that it would be useless.

Hooks in React ....... and bonus content on using photos in your applications

Alyssa Falcione — Tue, 21 Jun 2022 22:18:03 +0000

Goodbye classes, Hello hooks!

I'll admit, I haven't really had to use classes very much seeing that I am new to programming and React Hooks were introduced in February of 2019, but that doesn't mean I can't have full appreciation of them. I of course have delved into classes just to have the general knowledge, and with the short amount of time we have spent together, I am highly grateful for the release of React 16.8 and Hooks.

The most notable thing about React Hooks is how they allow programmers to reuse stateful logic without having to change the hierarchy of their components. This allows for programmers to share Hooks with many components, which in turn, makes our lives much easier. Classes did not give us this flexibility. This does not mean that coders have to refactor previous code or discontinue the use of classes, as it is still an option to use them.

And guess what?! We can even build our own hooks! However, I just want to go through two of the more common ones used in day to day coding. Also, keep in mind that hooks will not work inside of classes, they're meant to be used instead of writing classes.

Let's talk about UseState();

Let's look at a code snippet from reactjs.org that shows the use of state

import React, { useState } from 'react';

function Example() {
  // Declare a new state variable, which we'll call "count"
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
}

As you can see, we must import our hooks from React.

What UseState() does is allow a state variable to be declared. This allows us to preserve values between function calls. This would be the same use as this.state with classes except it does not disappear when the function exits, rather React will preserve its state.

When using state, we use const to declare a new state variable and we have the option to name our variables as we please. In the example above, we used "count" which is set at an initial value of 0. React will remember the value, or rather, argument that we passed to useState. Unlike with classes, we can pass a number or a string to state rather than only an object. The second variable in our example above is the setCount. This is actually a function that will update our state.

We can now use the variable count directly as seen below:

<p>You clicked {count} times</p>

Now let's update state!

This is where our setCount function comes into play. Since we already have our variables in play, this is how we can update our state

 <button onClick={() => setCount(count + 1)}>
    Click me
  </button>

Keep in mind that if you want to store two different values in state, you will have to call useState() twice.

UseEffect();

This hook will run a function every time the component renders. Components render when it first loads initially and also when state changes it will reload to update the browser. This can be very useful so that we can create side effects when desired, such as for when specific values in your application may change.

Below is an example of how to implement useEffect() from reactjs.org

import React, { useState, useEffect } from 'react';

function Example() {
  const [count, setCount] = useState(0);

  // Similar to componentDidMount and componentDidUpdate:
  useEffect(() => {
    // Update the document title using the browser API
    document.title = `You clicked ${count} times`;
  });

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
}

As you can see, just like any hook, you must import it from React. With useEffect implemented above, the function inside of useEffect will run during any rendering.

When you want to specify when to re-render with useEffect, you can use something called a dependency array. Below is an example.

useEffect(() => {
  document.title = `You clicked ${count} times`;
}, [count]); // Only re-run the effect if count changes

As you can see above we added a dependency array with [count]. This will only re-render when count changes.

You can also provide a clean up function within your useEffect such as seen below:

useEffect(() => {
  performSideEffect();
  return cleanUpFunction;
}, []);

Notice how above there is an empty dependency array. The purpose of this is to only re-render on initial load rather than the hook being executed on both initial load and update.

This was just a short look into the magic that useEffect() can allow!

Okay so I promised bonus material, so here we have it.

I am not sure that this is common knowledge since it took me some time to figure out how to do it so I wanted to sure it with the coding community.

Yeah, you can host them on a free site, but I like this way better.

Start with saving the photos you want to use to your desktop in JPEG format.

Next you will navigate to GitHub and choose ANY repository, then navigate to the "Issues" tab.

You will then open a new "Issue" as seen below

You can then drag your photo from your desktop to the "write" section

Copy the highlighted text. This is the link you will use in your React.Js application.

Voila! And there you have it, an easy way to use photos in your application!

Happy Coding!

Who Doesn't Love a Petting Zoo?

Alyssa Falcione — Tue, 22 Feb 2022 20:43:24 +0000

Okay, so it may not be a traditional petting zoo, it's actually a memory card game with adorable animals, and we all love adorable animals. I do admit, I am biased here because the animals in the cards are either my own or pets of friends. What makes it a petting zoo? Well I just edited the cursor to a hand while the user is hovering over the animal cards to give the effect of "petting".

I knew I wanted to create a game of some sort as my first project. I threw around the idea of making a tamagotchi giga pet-like application, but the memory game took the cake, mainly because I got to incorporate my animals into it while learning a few new-to-me concepts. I am happy with my decision as this was such a fun challenge to tackle for my first project.

What I learned

A card game always has to have a built-in shuffle feature otherwise the game would be too easy! The best way I found to do this? Randomizing arrays! This was a key concept I learned that really helped my game to be successful.

const randomize = () => { const cardData = cards; cardData.sort(() => Math.random() - 0.5); return cardData; }

I found method chaining to be the most efficient way to achieve this goal (for this purpose). As you can see in my code snippet above, I used a customized array.sort() method and math.random function to accomplish this. Since the sort function looks for either negative or positive numbers in order to determine whether to move the item in the array or not, I used math.random() and subtracted 0.5 as a baseline so we'll randomly get negative and positive numbers, which in turn randomly shuffles the items in the array.

Utilizing Event Listeners

For a game to be interactive, event listeners are a must. This project only required 3 event listeners but I doubled the expectations to increase interactivity. I coupled event listeners with alerts to start, restart or pause the game.

Starts Game

const startBtn = document.getElementById("start-btn"); startBtn.addEventListener("click", () => { cardGenerator(); startTimer(); });

Restarts Game

const resetBtn = document.getElementById("restart-btn"); resetBtn.addEventListener("click", refreshPage);

function refreshPage() { if (confirm("Are you sure you want to restart the game?")) { reloadCards(); } }

Pauses Game

const pauseBtn = document.getElementById("pause-btn"); pauseBtn.addEventListener("click", pauseGame);

function pauseGame() { alert("Press Ok to Resume Game"); }

JSON Document Database - Stretch Goal

Originally when I wrote my program, I did not utilize db.json. I had just created my card data as an array within my index.js file. I felt eager to reach the stretch goal so I decided to take on the challenge. I did so by creating my card data in db.json and used a fetch request to access the data. So my code went from this:

In index.js
const getData = () => [ // without curly brace, it automatically returns {imgSrc: "images/kit.jpeg", name: "Kit"}, {imgSrc: "images/Pixel.jpeg", name: "Pixel"}, {imgSrc: "images/Salvador.jpeg", name: "Salvador"}, {imgSrc: "images/Tongo.jpeg", name: "Tongo"}, {imgSrc: "images/Voltaire 8.jpeg", name: "Voltaire"}, {imgSrc: "images/Zion.jpeg", name: "Zion"}, {imgSrc: "images/Yadda.jpg", name: "Yadda"}, {imgSrc: "images/Jenny.jpg", name: "Jenny"}, {imgSrc: "images/kit.jpeg", name: "Kit"}, {imgSrc: "images/Pixel.jpeg", name: "Pixel"}, {imgSrc: "images/Salvador.jpeg", name: "Salvador"}, {imgSrc: "images/Tongo.jpeg", name: "Tongo"}, {imgSrc: "images/Voltaire 8.jpeg", name: "Voltaire"}, {imgSrc: "images/Zion.jpeg", name: "Zion"}, {imgSrc: "images/Yadda.jpg", name: "Yadda"}, {imgSrc: "images/Jenny.jpg", name: "Jenny"} ];

To this:

In db.json
{ "cards": [ { "id": 1, "name": "Jenny", "imageSrc": "images/Jenny.jpg" }, { "id": 2, "name": "Pixel", "imageSrc": "images/Pixel.jpeg" }, { "id": 3, "name": "Kit", "imageSrc": "images/kit.jpeg" }, { "id": 4, "name": "Salvador", "imageSrc": "images/Salvador.jpeg" }, { "id": 5, "name": "Tongo", "imageSrc": "images/Tongo.jpeg" }, { "id": 6, "name": "Voltaire", "imageSrc": "images/Voltaire 8.jpeg" }, { "id": 7, "name": "Zion", "imageSrc": "images/Zion.jpeg" }, { "id": 8, "name": "Yadda", "imageSrc": "images/Yadda.jpg" }, { "id": 1, "name": "Jenny", "imageSrc": "images/Jenny.jpg" }, { "id": 2, "name": "Pixel", "imageSrc": "images/Pixel.jpeg" }, { "id": 3, "name": "Kit", "imageSrc": "images/kit.jpeg" }, { "id": 4, "name": "Salvador", "imageSrc": "images/Salvador.jpeg" }, { "id": 5, "name": "Tongo", "imageSrc": "images/Tongo.jpeg" }, { "id": 6, "name": "Voltaire", "imageSrc": "images/Voltaire 8.jpeg" }, { "id": 7, "name": "Zion", "imageSrc": "images/Zion.jpeg" }, { "id": 8, "name": "Yadda", "imageSrc": "images/Yadda.jpg" } ] }

Reformatting my code this way allowed me to use the skills I learned to transmit data in a web application. After this project, I will always take the stretch goals on as a challenge. It allowed me to test my knowledge and to apply what I have learned already while learning some new concepts. Here's to the first of many projects! Thanks for joining me on this journey.

Feel free to check my project out on Github!

Computer Science versus The Science I Know

Alyssa Falcione — Fri, 21 Jan 2022 22:24:09 +0000

Well, I’m officially en route. On my way to switching over to a new field of science. When I tell people, everyone says "What a drastic change!" They're not wrong. Veterinary Science is already so vastly different from most other biological sciences. Then compare it to Computer Science; They're in different dimensions! I’m still a newbie to the world of CS, but I can tell you the differences I’ve noticed so far.

My hands are being utilized in a much safer, more elegant way. I haven't once had my mouse try to bite me, or accidentally stabbed myself with the instrument I call my keyboard. I'm not growing different pathogens or replicating viruses. I instead, installed antivirus software. So as far as the safety of the field goes, Computer Science takes the cake.

The attire is comparable. Scrubs versus pajamas. Wait… everyone codes in their PJ’s, right? I'm not afraid to admit that I have been. I like to be cozy while learning.

I haven't once heard the mention of grant writing, nor have I had to sit next to the "stinky" one in the lab. And by stinky, I’m referring to the scientist that grows stinky bacteria. This new field seems to smell much better.

So far, those are the main differences I have found. I know there will be more to come, and maybe I'll come back here and share with you my very scientific findings.