DEV Community: Blake Cooley

VR with A-Frame

Blake Cooley — Sun, 05 Apr 2020 22:44:07 +0000

Last week I talked about the awesome AR.jsthat allows you to create cool augmented reality applications with only Javascript. This week I'm going to dive into AR.js's one dependency, A-Frame, and see how it makes the magic happen.

What is A-Frame?

Originally conceived within Mozilla, A-Frame is a web-framework for building virtual reality experiences. Being based on top of HTML makes it simple to get started. A-Frame is now maintained by Supermedium and is an independent open-source project. It can be used within the browsers with mouse controls and supports most VR headsets such as the Vive, Rift, Gear-VR, and Oculus using motion controls.

The core of A-Frame is it's entity component that lets you define objects and their attributes: these can be your own 3D models or some of the primitives objects provided by the frame work(a-box, a-sphere, a-sky, etc).

Code example

Here is an example of A-Frame at works, you can see this example live here.

<html>
  <head>
    <script src="https://aframe.io/releases/1.0.4/aframe.min.js"></script>
  </head>
  <body>
    <a-scene>
      <a-box position="-1 0.5 -3" rotation="0 45 0" color="#4CC3D9"></a-box>
      <a-sphere position="0 1.25 -5" radius="1.25" color="#EF2D5E"></a-sphere>
      <a-cylinder position="1 0.75 -3" radius="0.5" height="1.5" color="#FFC65D"></a-cylinder>
      <a-plane position="0 0 -4" rotation="-90 0 0" width="4" height="4" color="#7BC8A4"></a-plane>
      <a-sky color="#ECECEC"></a-sky>
    </a-scene>
  </body>
</html>

As you can see, the only thing we have to do is toss in A-Frame as a script tag in the head, no installation required.

Inside the body we have our a-scene, the container for the 3D scene we're trying to create. Inside of that we have five primitives. A-Box, a-sphere, and a-cylinder, each being an entity we declare with size and color properties. Under there, both in the code and the render, we declare a a-plane, and finally, we declare an off-white a-sky entity.

Aframe's site has a lot of other examples, both using mouse controls and VR motion controllers. This one is my favorite, nothing says VR like 80's vaporwave a e s t h e h i c.

You can check out the collection of example available here at A-Frame's website, if you click "View Source" in the top corner it will open them in a separate tab and you can use the developer tools to look at the code, or click "Visual Inspector" to see how each entity is defined, you can even click each one to mess with their properties and watch the scene change in real time!

Conclusion

VR doesn't have to be hard and it's certainly not as daunting of a task as it might seem. Using A-Frame you can create 3D VR environments in a matter of minutes instead of hours, and being an open-source project means it's completely free and will constantly be made better by the community. I look forward to playing around with A-Frame and seeing VR continue to grow.

As VR headset development continues they'll become cheaper and more accessible to the public, so now is a good time to get ahead of the curve and create some awesome VR experinces!

Augment Reality with AR.JS

Blake Cooley — Mon, 30 Mar 2020 04:44:55 +0000

If you ever want proof that we're truly living in the cyberpunk future you can look at our corrupt governments, massive megacorporations and the massive spread of misinformation. Or, on the more fun side, augmented and virtual reality is pretty neat too.

It seems like it would be pretty hard to do, using a camera to track an area and render out a 3D model where no such thing exists, but with A-Frame and AR.JS it's surprisingly easy.

What is AR.JS?

AR.JS is a lightweight javascript framework that allows you to create image tracking, marker tracking, and location based AR experiences for either mobile devices or the web using a camera.

It's completely web-based, requiring no installation, just Javascript and the A-Frame or three.js VR frame work to work. It's also completely free and open source bringing the awesomeness of AR to the masses!

Below is a example of the image tracking code. Visit this link and point your camera at this image to see it live.

<script src="https://cdn.jsdelivr.net/gh/aframevr/aframe@1c2407b26c61958baa93967b5412487cd94b290b/dist/aframe-master.min.js"></script>
<script src="https://raw.githack.com/AR-js-org/AR.js/master/aframe/build/aframe-ar-nft.js"></script>

<style>
  .arjs-loader {
    height: 100%;
    width: 100%;
    position: absolute;
    top: 0;
    left: 0;
    background-color: rgba(0, 0, 0, 0.8);
    z-index: 9999;
    display: flex;
    justify-content: center;
    align-items: center;
  }

  .arjs-loader div {
    text-align: center;
    font-size: 1.25em;
    color: white;
  }
</style>

<body style="margin : 0px; overflow: hidden;">
  <!-- minimal loader shown until image descriptors are loaded -->
  <div class="arjs-loader">
    <div>Loading, please wait...</div>
  </div>
  <a-scene
    vr-mode-ui="enabled: false;"
    renderer="logarithmicDepthBuffer: true;"
    embedded
    arjs="trackingMethod: best; sourceType: webcam;debugUIEnabled: false;"
  >
    <!-- we use cors proxy to avoid cross-origin problems -->
    <a-nft
      type="nft"
      url="https://arjs-cors-proxy.herokuapp.com/https://raw.githack.com/AR-js-org/AR.js/master/aframe/examples/image-tracking/nft/trex/trex-image/trex"
      smooth="true"
      smoothCount="10"
      smoothTolerance=".01"
      smoothThreshold="5"
    >
      <a-entity
        gltf-model="https://arjs-cors-proxy.herokuapp.com/https://raw.githack.com/AR-js-org/AR.js/master/aframe/examples/image-tracking/nft/trex/scene.gltf"
        scale="5 5 5"
        position="50 150 0"
      >
      </a-entity>
    </a-nft>
    <a-entity camera></a-entity>
  </a-scene>
</body>

To briefly explain what's going on here:

"a-scene" defines the the A-Frame container where all of the magic will happen, nested inside of that is "a-nft" which define the Natural Feature Tracking (NFT) marker that will be used to render out our 3-d model defined in "a-entity".

Combine all three of these and now you can render out a 3-d T-Rex wherever the image is detected by your webcam or mobile camera.

This same effect can be achieved using markers, such as QR codes, some default ones are provided in the AR.JS docs.

This is just the tip of the iceberg, and I'm pretty excited to explore more AR in the future, hopefully with how easy AR.JS is to implement we can see AR become more than the neat gimmick it has been so far.

Linden Scripting Language

Blake Cooley — Tue, 24 Mar 2020 01:11:04 +0000

Into the Metaverse

Way back in 2006 while watching TechTV I got my first glimpse at Second Life, the online social game that would take up huge chunks of my life from then on. At the time, and in a lot of ways even now, it was the coolest thing I had ever seen. This huge 3D world where everything was made by the users. The clothes you wear, the places you visit, and most importantly, the scripts that make everything run were all created by the people playing the game.

The scripting part in particular took my interest, and it's one of the primary reasons I started to learn coding. Making interactive creations, no matter how simple or silly they were, and watching them work was like magic. Now I just do it with mobile phones and browsers but the spark that created it all started off in Second Life.

It's for that reason I'm going to give you all a brief glimpse into the code that runs that digital world, LSL, or Linden Scripting Language.

What is LSL?

LSL is the language that all the scripts in Second Life run on. These sets of instructions can be put into any object you create inside of the game. It can be used to make all kinds of crazy things, from cars, guns, lights, doors, even games inside a game (meta, right?).

These scripts can be written and compiled in an in-game editor where they are executed by the game's servers. It's structure is largely based on Java and C but with an emphasis on states and events. But besides that it has many of the features you'd come to expect from a programming language: functions, flow-control with if and while statements, and operators.

If you want to script a door, it can have a state such as "open" or "closed", a lamp would have the states of "on" and "off", a digital firearm can be "loaded" or "empty", etc etc.

Events are the triggers in Second Life that fire off functions and change the state of an object. These event can be a variety of things, saying a certain string in the chatbox, clicking or bumping into an object, etc.

Hello World Avatar

Here is the most basic script in LSL, a simple "Hello World" that fires off when the object is "rezzed", or loaded into the world, and a chat message of "touched" when a user clicks on the object.

default
{
    state_entry()
    {
        llSay(0, "Hello, Avatar!");
    }

    touch_start(integer total_number)
    {
        llSay(0, "Touched.");
    }
}

And here's a breakdown of whats happening on each line:

default // All Scripts need a Default State

{ // this open curly bracket denotes the start of the state
    state_entry() // an event
    {
        llSay(0, "Hello, Avatar!"); // a function inside the event's curly brackets
    } // closed curly bracket closes the state_entry event

    touch_start(integer total_number)  // another event inside default state
    {
        llSay(0, "Touched."); // a function between the brackets of the touch_start body
    } // end of touch start
} // Code end

And here's an example of script that turns an object from a white texture to black on click, something that could be useful for, say, a lamp or light fixture:

default //default state is mandatory
{
    state_entry() // runs each time the state is entered
    {
        llSay(0, "turning on!"); //object speaks!
        llSetColor(<1.0, 1.0, 1.0>, ALL_SIDES); // sets no tint (white)
        // note the semicolons at the end of each instruction
        // (do not put them at the end of "if" statements)
    }

    touch_end(integer total_number) // another event with only one function inside
    {
        state off; // sets the script to a new "state" and starts running "state off"
    }
} // this curly bracket ends the body of the default state.

state off // a second state besides "default"
{
    state_entry() // this is run as soon as the state is entered
    {
        llSay(0, "turning off!");
        llSetColor(<0.0, 0.0, 0.0>, ALL_SIDES); // sets black tint
    }

    touch_end(integer total_number)
    {
        state default;
    }
}

Finally, here's something I created. This script takes an image consisting of each still frame of an animated gif and modifies it's positioning on each tick to create an animated texture in game, which I then tossed into a pair of sunglasses someone made to create this cool static effect on the lenses.

 integer animOn = TRUE; //Set to FALSE and call initAnim() again to stop the animation.
  5 //Effect parameters: (can be put in list together, to make animation have all of said effects)
  6 //LOOP - loops the animation
  7 //SMOOTH - plays animation smoothly
  8 //REVERSE - plays animation in reverse
  9 //PING_PONG - plays animation in one direction, then cycles in the opposite direction
 10 list effects = [LOOP];
 11 //Movement parameters (choose one):
 12 //ROTATE - Rotates the texture
 13 //SCALE - Scales the texture
 14 //Set movement to 0 to slide animation in the X direction, without any special movement.
 15 integer movement = 0;
 16 integer face = ALL_SIDES; //Number representing the side to activate the animation on.
 17 integer sideX = 1; //Represents how many horizontal images (frames) are contained in your texture.
 18 integer sideY = 1; //Same as sideX, except represents vertical images (frames).
 19 float start = 0.0; //Frame to start animation on. (0 to start at the first frame of the texture)
 20 float length = 0.0; //Number of frames to animate, set to 0 to animate all frames.
 21 float speed = 10.0; //Frames per second to play.
 22 initAnim() //Call this when you want to change something in the texture animation.
 23 {
 24     if(animOn)
 25     {
 26         integer effectBits;
 27         integer i;
 28         for(i = 0; i < llGetListLength(effects); i++)
 29         {
 30             effectBits = (effectBits | llList2Integer(effects,i));
 31         }
 32         integer params = (effectBits|movement);
 33         llSetTextureAnim(ANIM_ON|params,face,sideX,sideY,     start,length,speed);
 34     }
 35     else
 36     {
 37         llSetTextureAnim(0,face,sideX,sideY, start,length,speed);
 38     }
 39 }
 40 
 41 fetch()
 42 {
 43      string texture = llGetInventoryName(INVENTORY_TEXTURE,0);
 44             llSetTexture(texture,face);
 45             list data  = llParseString2List(texture,[";"],[]);
 46             llOwnerSay( llDumpList2String(data ,","));
 47             string X = llList2String(data,1);
 48             string Y = llList2String(data,2);
 49             string Z = llList2String(data,3);
 50             
 51             // llOwnerSay("X=" + X + " Y=" + Y + " Z = " + (string) Z);
 52             
 53             sideX = (integer) X;
 54             sideY = (integer) Y;
 55             speed = (float) Z;
 56             if(speed) 
 57                 initAnim();
 58 }
 59 
 60 default
 61 {
 62     state_entry()
 63     {
 64         llSetTextureAnim(FALSE, face, 0, 0, 0.0, 0.0, 1.0); // V2 - remove all anims
 65         fetch();
 66     }
 67     changed(integer what)
 68     {
 69         if(what & CHANGED_INVENTORY)
 70         {
 71             fetch();
 72         }
 73     }
 74 }

And this is, obviously, just the tip of the iceberg of what you can do with LSL. Better coders than I have made some truly amazing things in the game. If you'd like to know more about LSL check out the SL wiki and maybe even download the game and give it a shot (just, uh, avoid the adult sims).

Intro To Mobile Development

Blake Cooley — Mon, 16 Mar 2020 09:59:14 +0000

So far the applications I've made throughout my bootcamp journey have all been browser based web apps but for our final project our group decided to make the jump into mobile development.

Developing on mobile has some unique differences and hurdles to overcome over what we're used to as we learned, but in a world where everyone has a little black mirror in their pocket you'd be selling yourself short as a software developer not to make the jump.

Key Differences

Working as a front-end developer for a web application has you manipulating the DOM, Document Object Model, the source of all the HTML that makes your (hopefully) awesome website work. First we did it just by hammering out HTML, then came JQuery, and finally MVC's like React or Angular.

In mobile, you'd don't have a DOM, instead you work with Views. All those old tricks you used before to make stuff look fancy no longer apply. Even styling libraries like Bootstrap can no longer give you fancy buttons and such, as there's no HTML to be had, instead you have to use something like React Native Elements (or an equivalent for whichever native framework you're using) to render those elements out as components instead.

The next big hurdle is your server side code, for a web application connecting your front-end and back-end is much easier. There's no issue at all hosting both of the code on your deployment server of choice- but for mobile applications you can't bundle the two together. Your backend code needs to be hosted somewhere on the web your mobile application can hit, leaving all the heavy lifting to that server while your client end stays fairly lightweight.

This is a process that, as one of my partners found out, is not so easy. All those nice debugger tools like the Chrome Dev Console are no where to be found. So when something doesn't work, you don't have the luxury of console logs and breakpoints to give you a quick easy look at whats going on under the hood.

And one of the biggest hurdles I've had to face so far is actually getting to see how your application is going to look on a mobile device. Using Expo does give you a nice feature that lets you scan a QR code to display a version of code on an actual mobile device, but that presents it's own difficulties during local testing when trying to hit your backend code.

The more practical solution is to use an emulator, either through Android Studio or XCode for Android and iOS repectfully (as well as some third party software like Genymotion). Though if you're running a fossil of a laptop like mine, be prepared for headache. You're running a simulated version of an entire device, so be prepared for lag, locks ups, or if you're me, just straight up crashing.

Not Hard, Just New

Despite all the hoops I have to jump through, I'm looking forward to learning more about mobile development- both for the boost it'll give to my hire-ability but also for the challenge of learning something new. Right now I don't have many answers for the problems I've listed here, but I'm excited to figure them all out and hopefully share them with you all soon!

Wish me luck, and email me some RAM, please.

Google Cloud

Blake Cooley — Mon, 09 Mar 2020 04:55:27 +0000

If you're new to deployment and are thinking of using Google Cloud, I have one word of advice: Don't.

Don't get me wrong, there's a lot to like about their systems. If you're deploying a simple app or a webpage the process is fairly painless, but as I found after three days of frustration, furious Google searches, and page after page of lengthy documentation it's not always as easy as those friendly videos would lead you to believe.

The Good

Before I regal you with my tales of Google-based woe, first lets talk about what it does right.

If you're making a new account, Google gives you a rather generous free trial to test out their services- 300$ dollars worth to be exact. If you're deploying something that doesn't use a database those dollars will stretch a long way, standing in stark contrast to a certain other cloud-computing service that is quick to bill you.

You have the option of either using the SDK which let you run the various commands you might need directly from your local machine's terminal or failing that there's always a handy web-based terminal waiting for you in the top right of your dashboard.

There's a few cloud computing options for whatever needs you might have, though the one I used was App Engine:
-App Engine is a scalable option that automatically creates new instances as your traffic increases. It also takes much of the legwork away from you, all you need to do is add an .yaml file with some basic configuration then either push your repo from Github or, if you have the handy SDK installed, use 'gcloud app deploy' from your app's directory and a few minutes later- you're live, baby!

The Bad

First, let's talk about documentation. It all sucks, it's just a fact of life that you're future as a software engineer would be filled with two brands of crappy documentation: horribly vague lists of functions and keywords with maybe a 'hello world' quick-start guide OR massive tombs of information that would put encyclopedias to shame and leave your head spinning.

Google's doc's come in the latter form. Page after page with links that lead to more and more pages, until your is so full of tabs you can barely find the x's to close them. It's a rabbit hole you'll find yourself diving into the second you have a problem and the sheer amount of information at hand means finding the solution you need is like finding a needle in a exponentially large haystack.

My three day long dive into their documentation was over what seemed to be a simple problem, connecting the CloudSQL database to the NodeJS backend on my app. The guide they provided was simple enough to follow...the problem is, it didn't work. It was only by the grace of one of my colleges who'd face my problem before did I finally find the answer I needed: an obscure beta setting I pasted into my .yaml file that suddenly made the entire thing work- and the only reason she had found that was due to her having twice the time I had to dig through the wizardly tome of information on the web.

The Ugly Conclusion

Despite my protests to the contrary, Google Cloud isn't the worst thing in the world. When it works, it works well, but when it doesn't it can be a nightmare. Though, in my brief experience with deployment: it's always going to suck. Just be prepared for the pain, have a bottle of aspirin ready, and solider on through.

Document vs Relational Databases

Blake Cooley — Mon, 10 Feb 2020 03:36:42 +0000

When it comes time to pick the database you'd like to use for the back-end of your particular application you have two choices for the type you'd like to use. Relational, or SQL, databases and Document, or noSQL databases.

In general terms, a SQL database is any that uses Structured Query Language and a noSQL database is well...those that do not. So, lets get into what exactly that entails.

SQL/Relational

As mentioned above, SQL databases use Structured Query Language which was developed by IBM in the 1970's. SQL stores data in a schema that uses tables with columns and rows. In the most basic example, you can think of a SQL database like a phone book: each column would be the phone-number, name, and address while each row would be relation for each particular person. You can use one of of those three data-points to find the others, if you know a person's name you can find their address and number. (Especially if you can scan through the entire phonebook in a matter of seconds like a computer.)

Each of these tables can also cross-reference other tables where those data-points might intersect. These relationship are either a one-to-many relationship (one users can have many blog posts), or a many-to-many relationship (each of those blog posts can have many comments). Below you can see an example of a schema for a chat application using dbdiagram.io.

CREATE DATABASE chat;

USE chat;

CREATE TABLE `messages` (
  `id` int PRIMARY KEY AUTO_INCREMENT,
  username varchar(20),
  `id_user` int,
  `room_id` int,
  `text` varchar(250),
  roomname varchar(20)
);

CREATE TABLE `rooms` (
  `id` int PRIMARY KEY AUTO_INCREMENT,
  `name` varchar(20)
);

CREATE TABLE `users` (
  `id` int PRIMARY KEY AUTO_INCREMENT,
  `username` varchar(20)
);

Relational databases are very useful for situations where you might have a lot of data that intersects with each others, though it takes a fair bit of planning as each field must have it's data-type specified, and in the case of strings you also need to declare the maximum character limit.

Document/NoSQL

Document databases don't require the careful planning of a SQL database but are more limited in their use. They instead store data in collections consisting of documents (something like a JSON). You can picture a document database like a filing cabinet and the collections as folders. The folders/collections will tell you what type of document is inside them but you can't access the information inside those documents until you pull them out of the folder.

This offers a lot more flexibility as you don't have to meticulously plan out your data into tables but this comes at the cost of speed and size. Since you're just storing full on objects you'll have to pull them out of the database and into your application to get any specif data instead of just querying what information you're looking for in particular like in a SQL database.

Which should you use?

That depends entirely on what kind of data you're working with and what you plan to do with it. If you're working with lots of unorganized data then a document database might suit you better, if your data is more structured and you application needs to access specific information and how it related to other data-points then a relational database is a better fit.

Dealing With Impostor Syndrome

Blake Cooley — Mon, 03 Feb 2020 05:00:15 +0000

Every Monday morning is motivational Monday at Operation Spark, where the students and teachers gather up in a circle to sum up the coming week's events after a mantra:

"I belong, you belong. I'm smart, you're smart. I'm talented, you're talented...."

When I first had to do it, it made my eyes roll and gave me flashbacks of working at Wal-Mart with their equally cringe chants every morning of my painful stint in retail. But after one of my roughest weeks in the program, I understand the importance of it.

What you're getting into

If you ever take a look at the Programmer Humor subreddit, you'll notice a common theme: Coding is pain.

Countless hours of debugging and scary red error messages- only to find it was a typo your brain just completely ignored.
Installing a program you desperately need to make a project that won't work and finding one forum post from 2008 with no solution to the exact obscure error you're having.
Scouring page after page of documentation that reads like a stereo manual just to find that one freakin' command you need.
Making a Stack Overflow post for what you felt like was a insurmountable problem only to be meet with snark and bile because god forbid you ask a question that someone else already did.

This is just a small list of the frustration that awaits you.

But the worst part is, sometimes you just don't get it. You sit there staring at the screen and your bajillion tabs open in Chrome and all you want to do is bash you face against the keyboard. Tossing code at the wall, hoping it sticks.

All the while frustration mounts as the clock ticks down to your deadline, and if you're anything like me: you just snap.

The Downward Spiral

Sitting on the steps outside of the building, puffing on a cigarette, the thoughts started creeping in.

"You're not cut out for this, you're too dumb to figure this stuff out, you're going to fail the test and waste six weeks of your life thinking you could be some code cowboy."

Next thing I knew I was hiding in the bathroom, tearing steaming down my face, seriously debating swearing off every touching a keyboard again. But as my colleagues and teachers reminded me: Everyone has been there.

That feeling of being lost, frustrated, and confused is a common experience- not just in coding but in life in general. Nothing worth doing comes without pain and hurting now only makes you stronger later.

Pulling Yourself Back Up

The most important thing is, don't beat yourself up for that moment of weakness. Anxiety, doubt, and depression have been plaguing people for as long as there have been people. As Shakespeare had written in Measure for Measure:

“Our doubts are traitors,
and make us lose the good we oft might win,
by fearing to attempt.”

And we've been talking about that guy for hundreds of years, so he must of been onto something.

So, just remember, 'I belong, I'm smart, I'm talented. You belong, you're smart, you're talented.'

Keep fighting, struggle through the pain, come out the end a better person, and don't feel discouraged when the darker parts of your mind creep in.

Installing Linux or How I Stopped Worrying and Learned to Love the Penguin

Blake Cooley — Mon, 27 Jan 2020 04:32:35 +0000

Why I made the jump:

Windows is great for a lot of things but using it as your development environment, not so much. Sure, Microsoft has made some advancements recently that makes things easier: virtual desktop support on Windows 10, Windows Subsystem for Linux, and the oh so wonderful VSCode, but it's not without it's headaches even still.

One of the problems is you actually need Windows 10 to get the aforementioned features and if you were like me with a absolutel fossil of a laptop still running Windows 7 you're left with the nightmare of actually installing it. I still have PTSD over loosing an entire day's worth of course work due to downloading 40 gigs worth of OS. Who knows many hours of sleep I've lost to waking up in a cold sweat, the memory of that sky blue screen mocking me with it's slowly creeping percentage while my colleagues coded away.


THE HORROR

Afterwards my experience with coding on Windows was still a bumpy ride- often times things never worked out of the box and needed some asinine work-around I'd spend way too long googling, and I was assured by many that it wouldn't get any better. So I decided to make the jump into the scary new world of an unfamiliar OS.

How to actually get it installed:

The first step you have to make is picking your distribution or distro. Linux just isn't one Linux, as an open-source OS there's a variety of versions that all have a different focus. Fancy yourself an ethical hacker who wants to find security holes to fix then give Kali a try. Maybe you want to fully embrace that open-source life and grab Fedora. Me? I just wanted to code with minimal headache and switch to a new OS with little learning curve- so I settled on Mint: a lightweight distro that comes preloaded with a Windows-esque GUI.


Seriously, there's a lot of 'em

From there, you actually got to install the sucker- thankfully Mint has some easy to follow documentation that lays out the process. You'll need some sort of boot medium- a usb drive preferably, but burning the ISO on a disk will also work. Next you'll slap your boot medium into your computer, restart it and change the boot order in your BIOS to load Mint. If you've never messed with BIOS before, check out this guide, it's not as scary as you might think.

Once you've set that up you'll boot into a live version of Mint that's running off of the boot medium. It'll operate the same as the real deal, though you won't be able to save any changes you make, this will give you a opportunity to click some buttons and make sure nothing exploded. Once you're satisfied that everything is in working order, run the install wizard located on the desktop which will walk you through the process of either formatting your drive for a pure Linux install, or set up a partition so you can dual-boot into either OS. And that's it. It was such a surprisingly easy experience I was left wondering why I was so worried in the first place.

What I think about it:

I've been using Mint for about a week now, and so far, I love it. All your familiar shortcuts work, and minus a few slight changes in the UI, it works almost exactly like a Windows OS. It feels natural to use and your average user will barely notice the difference. But the thing I really love the most is that if you start digging around and pushing buttons...you can break the crap out of it.

I know that sounds counter-intuitive. Why would you want something you can break? Because to truly get the most out of something you've got to take off the training wheels. Way back when dinosaurs roamed the earth and I got my first computer with Windows 98- I pressed every button, typed things in the command line I really shouldn't of, deleted files that bricked the entire OS, and had to re-install multiple times. But in doing so, I learned the in's and out's of that machine. Pulling it apart and looking at all the parts gave me a more intimate understanding of how to fix things when everything went fubar.

Linux gives you a lot of power. Can't run a command normally? Prepend sudo (super user do) to the front of it and BAM, you're the master of your own destiny. But, as Uncle Ben said in the superior Raimi Spiderman flicks (don't @ me), "Great power comes with great responsibility." If you run 'sudo rm -rf' in your root folder, you won't feel so good.


A visual representation of your hard drive when you run '$root sudo rm -rf'

On the topic of the terminal commands: they're likely my biggest gripe about Linux. Apparently the Linux devs have an allergic reaction to typing or easy to understand alias for commands. They're all some esoteric acronym followed by an entire alphabet of -flags that only a Google search will reveal the meaning of. grep stands for "Global regular expression print" which is a very useful command who's acronym sounds like a sound a dying animal would make.

Regardless, I've very much enjoyed my experience with Linux and I'm quickly becoming one of 'those people'. It's only a matter of time before I slap a penguin sticker on the back of my laptop and start making childish jokes about 'fsck', and I invite you to become one too.

Binary Search Trees

Blake Cooley — Sat, 18 Jan 2020 04:28:05 +0000

When you're coding you're going to use a lot of data. And when you're dealing with complex problems that use a lot of it, that data needs to be structured- you don't want it floating around all willy-nilly in the ether.

These data structures can be all kind of things, linked lists, arrays, hash tables. But today I'm going to be talking about trees: Binary Search Trees in particular, as one might of guessed from my uninspired title.

So, what the heck is a tree?

In computer science, a tree doesn't refer to those green leafy things you see scattered about the landscape, but rather a branching collection of nodes representing whatever values you're working with. These start with a singular root node (also called a parent) that is then connected to branches (or children) flowing downward.


Kinda like this, but with a lot more 1's and 0's

Where a Binary Search Tree, or BST's (much like military, coders love acronyms) differ is the amount of child nodes and how those nodes are structured. Each node in a BST can only have up to two nodes- that's where the binary part comes in- and are structured in such a way where the lower value is always to the left, higher to the right.

And this is how the above example might appear as a JavaScript object:

let parentNode = { 
value: 9,
leftChild: {value: 7},
rightChild: {value: 11}
}

Why the heck are they useful?

"So what's the big deal?", you might ask, "what makes BST's so special instead of an array or something similar?". Speed. Look-up speed in particular. Imagine if our tree wasn't just that one binary node, but a series of binary nodes, linked to more binary nodes, all structured in such a way that the lower value is always to the left, higher always to the right.


Like this one right here

If this was structured in an array instead, we might have to iterate over every index to find the value of, say, 42. This would give us a linear big O time complexity or O(n). But using a BST we can check the if the value of each child node is higher or lower than 42, and each time eliminate an entire branch of the tree from our potential search. This gives us a logarithmic big O time complexity or O(log n).

Where the heck are they used?

"Well, that's cool and all", I can hear you saying, "but what good has a BST ever done for me?" Here's a few examples of some real world implementations of binary search trees:

*Radix Tree - Used in almost every high-bandwidth router for storing router tables

*Huffman coding - compression algorithm used in .jpeg and .mp3 file-formats

And my personal favorite:

*Binary Space Partition - Used in 3D video games to determine which objects to render. The first ever use of Binary Space Partition being 1993's Doom.


This means by the virtue of association, BSTs are "the number one cause of decreased productivity in businesses around the world"

So the next time you crawl away from the cold blue glare of you computer screen and get a brief glimpse of those green leafy things outside, imagine them being upside down and full of data you can look up quickly. And then crawl back inside and implement a BST to handle whatever massive set of data you're working with.