A Dev To Be

We’ve so far covered creating a “Hello World” app using just the Rails API and also by integrating Rails with React but in this post we’re going to cover the standard, or “vanilla” approach by using views.

Creating a Project

Similar to what we’ve done in the earlier posts in this series, we will use the rails new command to create a new project. However, since we’re going to create a standard Rails app we will not use any special flags:

1

rails new hello_world

If you start the server and navigate to localhost:3000 you’ll see the familiar landing page. If you’ve read the previous posts, you’re probably guessing what we have to do next. Create a controller!

Creating a Controller

Hopefully this is becoming a little clearer as we go on but just to restate, we need to create a controller, which is a Ruby class that contains one or more methods, also referred to as actions. When run, this method will then fire off a view, which is a template that contains HTML and possibly some Ruby.

While we could create the controller and route separately by using the --skip-routes flag, it’s easier to have Rails take care of both for us as well as create the view for this controller. So let’s just run the following code:

1

rails generate controller hello_world index

This will create a controller with the file name hello_world_controller.rb and a method called index. It will also create a view with the same name as this method in our views folder.

Since we want the “Hello World” message to appear when we visit localhost:3000, or in other terms, the “root” of app, we need to make sure the routes file reflects this.

Create a Route to Root

Similar to how we did it in the previous post, we need to open the routes.rb file in the config directory and change it to the following:

1
2
3

Rails.application.routes.draw do
	root 'hello_world#index'
end

Remember how the generate command created a view for our index method automatically? All that’s left is to change it to reflect the text we want.

Modify the Index View

Open the index.html.erb file and replace it with the following:

1

<h1>Hello World!</h1>

Now, just give localhost:3000 a refresh and you should see this:

All done!

Conclusion

Well that wraps up this series of posts on how to write a “Hello World” Rails app in three different ways. Each way illustrated a different implementation of Rails.

1. Using Rails as a back-end only
2. Using Rails as a back-end paired with React
3. Using Rails as a full framework

See you at the next post!

Sometimes you may want to use Rails exclusively for the back-end of your app and React for the front-end. In this next post in our series of different ways to create a “Hello World” app in Rails, we’re going to show you how to set that up.

While there are a few different approaches to integrating React with a Rails app, we’re going to assume that we’re going to use Webpack in this app so we’re going to take the approach that installs React and integrates it with Rails all in one go.

Creating a Project

To create a new Rails app withe Webpack already pre-configured for React, we can run this command:

1

rails new react_on_rails --webpack=react

After this has finished (it may take a few minutes) cd into the new directory and open it up in your favorite IDE.

Once there, you will see the directories and files in the file explorer look pretty similar to standard layout when using the new command. If you expand the app directory though, you’ll see that there is now a javascript folder. This where all files related to React will be located.

Specifically, if you look in the /javascript/packs/ folder you will see a file called hello_react.jsx. This is the component of our Hello World app that comes as boilerplate however if run the Rails server, you will see this is not being served and instead we get the normal landing page. Let’s change that.

Create a Controller

Similar to how we did it in the previous post, we can create a controller using the generate command however we’re going to pass an additional parameter to the command after the name.

1

ruby rails g controller pages index

What the additional parameter of index does is create an empty method of the same name in the pages controller file.

After the command is run, if you open the pages controller you should see the following:

1
2
3
4

class PagesController < ApplicationController
	def index
	end
end

Create a Route to Root

Next, if we go to /config/routes.rb we can confirm that it also created a route to the controller. Since we want to see “Hello World!” instead of the landing page, let’s change that to the following:

1
2
3

Rails.application.routes.draw do
	root 'pages#index'
end

Now when someone navigates to root it will run the index method in our controller which will then serve the index view. If you open this file (index.html.erb) you will see it just has some placeholder text:

1
2

<h1>Pages#index</h1>
<p>Find me in app/views/pages/index.html.erb</p>

If you start the server (rails server) and visit the root page, that is exactly what you will see:

To see the React component from above, we’re going to need to inject it into this view.

Inject React into Rails

In order to do this, we need to first go back to the hello_react.jsx file. At the top, we we some comments describing exactly how to do this using the pack tag:

1

<%= javascript_pack_tag 'hello_react' %>

So let’s copy that and replace the html in our index.html.erb file with it. Now, if we reload the home page, you should see the text “Hello React”.

This post isn’t about how to create a ‘Hello React’ app though so let’s go to hello_react.jsx file and modify it so it looks like the following:

1
2
3
4
5
6
7
8
9
10
11

import React from 'react';
import ReactDOM from 'react-dom';

document.addEventListener('DOMContentLoaded', () => {
  ReactDOM.render(
    <div>
      <h1>Hello World!</h1>
    </div>,
    document.body.appendChild(document.createElement('div'))
  );
});

And there you have it!

In the third in final post in this series, we’re going to create our Hello World app using the “standard” Rails approach.

See you then!

How To Create a “Hello World” API Route in Ruby on Rails 6.1

When learning a new language, a traditional first program to write is one that simply prints “Hello World” to the console/screen. In this series of posts, I’m going to explain how to do that in Ruby on Rails through a few different methods.

In this post, I’m going to walk through a way to do this using just the Rails API. Let’s get started!

Installation

First, you’re going to need to install everything required to code in Ruby on Rails on your system. Since giving instructions for that would take a blog post on their own, I’m going to instead just provide the link I used to set up my system. It provides instructions for all operating systems so be sure to select the correct one:

https://gorails.com/setup/ubuntu/20.04

Good luck!

Creating a Project

Once you have everything installed, open up a terminal window your favorite IDE and navigate to the directory you want to create your project in.

Once there we’re going to create a new Rails app, but since we are building an app that will be an APIR server above all else, we don’t want the full-blown app, so we need to make sure to use --api flag which will do three main things:

1. Only configure our app to use a limited set of middleware
2. Make ApplicationController inherit from ActionController::API instead of ActionController::Base
3. Configure the generators to skip generating views, helpers, and assets whenever we generate a new resource

So let’s run the code:

1

rails new hello_word --api

Running the Server

You should now have a directory called “hello_world” with a bunch of other directories that are required for your app to work. To make sure everything is working as is, before we proceed let’s start the server that is included and see if we can see the home page.

In your terminal, enter the following command:

1

rails server

Then, open up a browser and navigate to localhost:3000. You should see the Rails home page:

Creating a Controller

Next we will need to create a controller, which is essentially a class with methods that we can refer to in our routes. These controllers are located in .rb files in the /app/controllers file. If you navigate there, you’ll see there is already one file, called application_controller.rb.

We’re going to leave that file alone though and create one of our own. To do so, just run the following command.

1

rails g controller hello

The g flag stands for generate and hello is the name of the controller. This will create a file called hello_controller.rb in the controller folder.

Once this has run, we’re going to define a method in the new controller to actually render the message “Hello World!” in our browser when the route gets hit.

To do this, we’re going to render out some HTML so navigate to the hello_controller.rb file and enter the following:

1
2
3
4
5
6
7

# /app/controllers/hello_controller.rb

class HelloController < ActionController
	def world
		render html: '<h1>Hello World!</h1>'.html_safe
	end
end

Creating a Route

Now that we have a controller, we need to create a route to point to it.

First, open the /app/config/routes.rb file since this is the file where we define all of our routes. Next, let’s say we want to render the above method when someone goes to the /hello route so enter the following line of code:

1
2
3
4
5

Rails.application.routes.draw do

	get '/hello', to: 'hello#world'

end

Now, when our Rails application receives an incoming request for GET /hello, that request will be dispatched to the hello controller’s world action.

Before we try it out, we can confirm if the route was successfully added by running rails routes and looking at the first entry:

Now, the moment of truth. If your server is running, let’s get it started with the rails server command. Then, open up a browser and go to http://localhost:3000/hello. Your page should look similar to the below:

And like that, we have written a hello world page using only a Rails API route!

In the next post, I’m going to kick things up a notch by explaining how to do this using a React front-end. See you then!

The Need for End-to-End Encryption

It seems that with every week that goes by there’s news of another huge company’s website being breached. This is followed often by a vague statement from said company saying something along the lines of they are “looking into the matter”^[1]. If they release any other information after that, they might spend one or two sentences discussing the information that was accessed but spend a lot more time making assurances that they “took immediate action”^[2] and that the breach will be under “continued investigation”^[2]

It’s usually not until security researchers start poking around that the scope of the breach is known. Often, it’s found that the records that were accessed number in the millions and contain sensitive information such as login credentials, birth dates, credit cards, social security numbers, etc. And it’s not long before these database dumps show up on the dark web for sale to the highest bidder and the genie is out of the bottle for good.

While most people affected by these breaches may only see a fraudulent charge on a credit card which is quickly taken care of by their credit company, unfortunately many breaches contain all the information needed for someone’s identity to be stolen and used for much more damaging purposes. For example, in 2018 36% of identify theft claims reported to the Federal Trade Commission were classified as being related to employment/tax fraud, bank fraud, and loan/lease fraud.^[3] These types of identify fraud are much more difficult to resolve and it can sometimes take victims years of fighting to rectify.

Sadly, these types of fraud are likely to continue to increase largely because the companies who were trusted with this information in the first place rarely face any substantial consequences. One of the biggest examples of this can be seen in the Equifax breach of 2017 where the records of over 147 million people were stolen.
As a result of a settlement with the FTC, Equifax ultimately only had to pay $125 to each victim but this was capped at $31 million meaning only .2 percent of the people affected were able to obtain this cash settlement. Equifax itself had to pay a fine which amounted to 2% of it’s yearly revenue but faced no other legal repercussions. ^[4]

An “easy” fix

Databases will continue to be compromised as shown above and our personal information will most likely accessed by unauthorized individuals/parties which leads to the question, what more can companies, or us as developers, do to protect user data? The answer is implementing end-to-end encryption.

In a very high-level explanation, when end-to-end encryption is used data is encrypted on the client-side, before it gets sent to the server. Similarly, it is also only decrypted on the client side as well. This means that the owner of the server where your data is stored is at not able to read your data, nor could it be read if it were somehow intercepted in transit.

Now normally, end-to-end encryption is hard to implement, which is why you won’t find it often in a lot of apps. That is, until a company Etesync came along and released an SDK called “Etebase” that it says “makes it easy to build end-to-end encrypted applications by taking care of the encryption and its related challenges.”^[5]

Is this really as easy to implement as they say? Well, in this series of articles we’re going to walk through the process of implementing Etebase in a simple app, starting with creating a user.

Create a new React App

To create the foundation for our app quickly, let’s leverage the “create-react-app” command that will give us everything we need by running the following command:

1

npx create-react-app etebase-signup && cd etebase-signup

If you run npm run start you should see your default browser open and inside that browser, the react logo. This is the default behavior so let’s make some changes.

Go to App.js and replace it with the following code which will render a very basic sign-up form with the functionality we need to capture the input:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

import React, { useState } from 'react';

function App() {
  const serverUrl = 'Your URL goes here';
  const [userData, setUserData] = useState({
    username: '',
    password: '',
  });

  async function Submit(evt) {
    evt.preventDefault();
    const formData = {
      username: userData.username,
      password: userData.password,
    };

    setUserData({
      username: '',
      password: '',
      confirmPassword: '',
    });
  }

  const handleChange = (evt) => {
    setUserData({ ...userData, [evt.target.name]: evt.target.value });
  };

  return (
    <form onSubmit={Submit}>
      <input
        type='email'
        name='email'
        value={userData.email}
        placeholder='Email'
        onChange={handleChange}
      ></input>
      <br />
      <input
        type='username'
        name='username'
        value={userData.username}
        placeholder='Username'
        onChange={handleChange}
      ></input>
      <br />
      <input
        type='password'
        name='password'
        value={userData.password}
        placeholder='Password'
        onChange={handleChange}
      ></input>
      <br />
      <button type='submit'>Register</button>
    </form>
  );
}

export default App;

Now that we have everything we need, we can move forward with installing Etebase, creating a server, and lastly, signing up a user

Install Etebase

First, let’s get Etebase installed so in your terminal run the following command:

1

npm install etebase node-fetch

After this is done, be sure to import etebase at the top of App.js like so:

1

import * as Etebase from 'etebase';

Sign Up For an Etebase Developer Account

Next we’re going to need sign up for a developer account with Etebase and get a server URL. Since they are still in beta, they are offering this for free so head on over to the below link to create the account:

https://dashboard.etebase.com/accounts/signup/

Once you’ve signed up and logged in, you should be given a server URL that you can use for testing. Copy this and paste it into App.js so that it is assigned to the serverUrl variable.

Create a User

Next, let’s add the few lines of code we need in order to register a user right before we clear the inputs. We’ll also include an alert to confirm the user has been registered:

1
2
3
4
5
6
7
8
9

const eteBaseUser = await Etebase.Account.signup(
  {
    username: formData.username,
    email: formData.email,
  },
  formData.password,
  serverUrl
);
alert(`Your user has been created!`);

This should be all we need to add a user; ideally we would want another field to confirm the password as well as some validation but we’re keeping it simple here for demonstration purposes.

Enter a username, email and password, press the Submit button, and you should see an alert pop-up confirming that the user has been created.

You can then navigate to your dashboard in Etebase, click on “Manger Users” in the User Management section and you should see the user created.

Conclusion

Well, they’re you have it, you are on your way to to getting your first end-to-end encrypted app off the ground.

See you at the next post!

A Quick Update

I'm noticing that there's a trend happening where I often go a month or longer without posting and it looks like I broke my previous record by it being two months since my last post.

The reason for this is I ended up passing the interview and got accepted into Fullstack! It has been exactly as advertised in that sucks up every second of free time you have available, forcing you to prioritize everything and unfortunately this blog has not made the cut. I have drafts of various posts written up but never had time to finish them. Having now made it to the mid-point though, this week is a bit of a "breather" week where we don't have any lectures and instead are encouraged to study up on any weak points and also explore new technologies not covered in the course yet.

Because of this, I thought I'd devote some time to getting this blog back on track and to kick it off I thought I'd dust off the oldest draft and wrap up my last post.

The Interview

As mentioned in this great article, How to Ace the Fullstack Academy Interview, after the coding assessment there is what I would categorize as a behavioral interview.

If you've ever been in a job interview, you'd find this very similar and can expect the questions to be in the same vein, asking you to give specific examples that illustrate you have the skills and experience to advance to the bootcamp. While I don't believe I can give the exact questions I asked, I would suggest looking up the STAR interview response method and trying to use that model to help your develop your responses. If you do that, you will be more than prepared for anything that comes up.

My experience ended up being great and I got along with my interviewer really well. I ended the Zoom call feeling that I had left nothing on the table and felt great about my chances of being accepted. Luckily I didn't have to wait long to find out and the next day, December 3 I received an email saying I had been accepted and outlining the next steps.

Going Forward

The Foundations phase, were you really get down the fundamentals of JavaScript, started on December 5th and since then it's just been non-stop learning. After Foundations we moved to the Junior phase, learning the backend (PostgresSQL, Express, Sequelize, and Node.js) and after that we learned the front end (React and Redux). As mentioned above, next week we will be moving on to the Senior phase which consists of pretty much using everything we learned to build web apps.

Going forward, my posts might be a bit random as I think the best way to keep this blog active is for me to talk about whatever is on my mind rather than stick to a path. The reason for this is that, when I promise that I will talk about a certain topic in my next post, if I'm not able to write that but have enough notes to put together a post on a different topic, I'll hold off since I feel I need to stay committed to what I said previously.

Hopefully this will result in less time between posts going forward!

As I mentioned in my previous blog post, I decided on Fullstack Academy as the coding bootcamp I wanted to attend. Since that post I have completed the Bootcamp Prep course, completed the coding assessment, and am now preparing for the interview which I have later this week. During this process I came across some things that I just thought I'd share in case someone else is considering doing the same down the line.

How to Apply to Fullstack Academy - Part I

So let's say you've decided to apply Fullstack Academy. What do you have to prepare for?

The Coding Assessment

Well first, you will have to take a coding assessment. This may seem strange to some since many would think, "Wait, I'm signing up to learn JavaScript but they expect me to know some first?" Well, yeah, pretty much. I know there are other bootcamps out there that have no expectations of any prior coding knowledge, but I found a somewhat common theme when researching those websites. When I'd come across a review on Reddit, YouTube, a blog, etc. and the reviewer comments on what they wish they would have done prior to signing up to increase their chances of success, they often said something like, "I wish I would have gotten the basics down before applying."

The reasoning for this is, as I'm sure you've come across many times, people equate a coding bootcamp to trying to sip water shooting out of a firehouse. There is just so much information to process and it's moving so fast that it's difficult to absorb.

For example, you can be pretty sure that you will be using an IDE in your bootcamp, probably Visual Studio Code since it's one of the more popular ones right now. If you’ve never had any experience with it before, and then one day of camp you're expected to install it and start using it efficiently, if any issue comes up you're going to quickly fall behind since the next day you'll be dealing with something different with it's own issues.

Because of this, I would wholeheartedly recommend doing as much as you can to learn the basics so that when you get to the real meat and potatoes of the course, you're not spinning your wheels from the start and can dedicate your time to focusing on the more important topics.

I went off on a bit of a tangent there, so to get back on track, yes, you need to have the basics down before you take the assessment. Good news, if you sign up for Fullstack's Bootcamp Prep course, it will teach you everything you need to know. My one big piece of advice on this though is, assume anything learned in that course will be fair game. You may get some advice of "focus on this" and "don't focus on that" but I would recommend not listening to that. Study everything you learned equally and get comfortable with it.

Finally, in regards to my own piece of "I wish I would have done this" word of caution is that once you apply, you will receive an email stating you have 48 hours to complete your assessment. I could have missed this but nowhere did I come across this tidbit. This is extremely important because if you are planning on studying more before taking the assessment, surprise, you only have 48 hours. Or, in my case, if you apply on a Sunday night thinking you can take the assessment at any time, surprise, you're going to have to take it on a Wednesday.

To Be Continued

Well, it turns out I had more to write about than I thought and it's getting late so I guess this will be a two-parter.

See you at the next post!

So, as you can probably tell by the date of this post compared to my last post, it's been almost two months since I've made an entry. Well, it's been a crazy two months.

I pretty much got so swamped with work, logging in way more than 40 hours a week almost all the way through October, that I had no time to code. As the days went by, I realized that my rough plan of taking some classes in my free time and gradually working up to an employable level of knowledge would not work. My job tends to be seasonal and there is no way I could go two months at a time, multiple times a year, not coding at all and expecting to progress.

I realized that I needed to really just make a decision. Did I really want to be a software engineer? If so, the only way I would be able to achieve that is by leaving my job and focusing 100% on programming.

There's a few problems with this though:

• I am the sole provider for my family
• We have limited savings to last on if I'm not working
• We're still in the middle of a pandemic so it seems absolutely nuts to quit a well-paying job at this time, especially given the above two points

Still, as I may have mentioned in a earlier post, I've played it safe my whole life without taking any real risks. Let's say I do quit my job to learn how to code and the worst case happens and I am unable find a job as a junior dev. Will I be able to find another job in my current profession? It might be difficult, and I might not make the same, but given my experience I think that is very likely.

So in the end, I might be out some money, but I could at least say I tried and not live my life with the regret of having not done so. Because of that, after talking it over with my spouse, we decided we were going to try.

Having already done research on coding bootcamps, I knew I wanted to go with FullStack Academy. That very night we made the decision I signed up for their Bootcamp Prep course; and I have to say, paying for that was a bit exciting as it felt like I was taking the first real step to a new career.

I then signed up for their free Intro to Coding course, which covers the very basics of HTML, CSS, and Javascript, and is intended for complete beginners to get them ready for the Bootcamp Prep course. Even though I have a small amount of experience with HTML and CSS, Javascript is new to me so I thought it would be a good fit.

After finishing the course, and the pre-work for Bootcamp Prep, I still had no doubts this was the right decision as I found everything just as fun and exciting as I have in the past.

Right now, I'm on my second week of Bootcamp Prep and it just feels right. The plan is then to apply, and if I get in, still work full-time while taking the first month of bootcamp which is supposedly manageable with only a 15-30 hour a week workload. The subsequent 3 months though will be intensive and the plan is to quit my job and focus 100% coding.

So in the end, my goal is to be a junior dev somewhere by the end of April 2021 and I plan to do everything I can to make that happen.

Part of "everything I can" is to continue learning in public which means continuing this blog. My idea is to give summaries of what I learn going forward along with my general thoughts and takes on the whole process of switching careers.

See you in the next post!

A little late with this post and don't really have time to make it long so it will just be quick.

As it's been a little while since I've been able to write or code, already some things were getting rusty so I had to search for how to do a few things.

Given I only have a few minutes today, I thought I would just do some maintenance, mainly check if there were any updates to Hexo. How do I do that again? Good thing I wrote a post about it. This learning in public thing is coming in handy.

Before I ran the update command in npm, I was curious if there was any way to see first what needed to be updated. After finding some packages I could install, I saw that there was something already baked in:

1

npm outdated

This gives a summary of the packages that need to be updated which resulted in the following:

To quote Steve1989MREInfo, "Nice."

This showed that there were some updates to be applied. I then ran the command I had discovered in my previous post:

1

npm update

It did its thing and after it was complete, I ran "npm outdated" again:

Hmm . . . that's strange. It updated Hexo and the theme I use but nothing else. I know I previously read about the differences between the "Current", "Wanted", and "Latest" columns but that was now a couple of weeks ago so it's time for a refresher to figure this out. Me thinks the color of the text is a clue but unfortunately I've run out of time.

Guess I know what my next post will be about. :)

I've had some stuff going on this past week and really haven't had time to code given they were higher priority and time-sensitive however I thought I thought I'd share my "syllabus" going forward.

As I mentioned earlier, while I have read conflicting information regarding whether having a CSS/HTML foundation is absolutely necessary, I just want to learn so I figured I'd start my journey there.

Back when I was still deciding what language to learn first, I had taken a beginner's Python course on Udemy by Colt Steele and really liked his teaching style. Because of this, I've been keeping an eye out for any of his free material and noticed that he had a free 4 day Code Camp that introduced beginners to HTML and CSS so I figured that would be a great place to get my feet wet, so to speak.

I'm currently on the Day 2 of the video and afterwards I'm thinking of taking Fullstack Academy's free bootcamp prep course which I believe is a much more comprehensive dive into HTML and CSS as well as the beginnings of Javascript.

See you next week!

Now that I've got the blog set up, the next step is to obviously start coding! But before I do, there's one more tool I needed to grab.

While I haven't yet made a post about what my plan is for becoming proficient enough to land a junior developer job, I'll drop a spoiler and say I am considering signing up for a bootcamp eventually. The thing with bootcamps is you need to make sure you are able to dedicate enough time to each week to meet their requirements otherwise it will just be money down the drain.

This part is tricky since I am currently working a full-time job so I don't exactly have a huge block of time during the week to dedicate to coding. Because of this, I need to get a realistic estimate of how much time I can dedicate regularly to coding. It's one thing to just say, "I will code X hours a day" but who knows if that will be achievable in practice.

So, I decided this week that I needed to find a way to track my time spent on this journey. I thought at first I would just crank out an Excel spreadsheet but I wanted to see if there were more elegant, ready-made solutions out there. I did a quick search on DuckDuckGo for "open source time tracker" and the first hit was something called Kimai. I went to their website, poked around a bit, and was surprised to see it checked all the boxes of what I wanted to do and even better, it was free!

Wanting to do my due diligence though, I spent 10 minutes or so looking at other options but ultimately came back to Kimai. It required that I run a local server but personally, I prefer that option to having something stored in the cloud, even if it is just my timesheets.

In the past, I've used XAMPP for running local servers but in this case, I saw that there was another software called AMPPS that was created by Softaculous which actually came with Kimai baked into it.

After watching and reading a few tutorials, I downloaded and installed AMPPS then Kimai and started setting it up.

The way Kimai works, based on my quick reading, is you can create a Customer who can have one or more Projects associated with them and each Project can have one more Activities. After ruminating a bit, I figured I would just have one Project which is "Learning to Code" and for now, the activities I would want to track would be the following:

• Blog
• HTML/CSS
• Javascript

Oh yeah, surprise, I decided I am going to learn Javascript as my first language and am thinking I should learn some HTML/CSS as well though the jury is still out on that (I've read conflicting opinions of whether that is still necessary). I definitely plan on writing a post later explaining my rationale behind this but I really am antsy to get to coding so I'm not sure when I'll get around to that.

So, after setting up Kimai here is how my first few timesheet entries look like since I started using it:

The dates and times are not exactly correct and I think it's because I did not set up the time zone correctly but I can address that later. I really only care about the durations. As you can see, as of now I've spent almost an hour in this session. Pretty snazzy stuff.

Well, that's it for this post. I now have everything I need to start coding and am super excited to start. I don't know if it's just pure optimism but I really think that this is something I can do and I can just see myself starting as a junior developer some time next year. Let's go!