Forem: Ryan Farney

Stacks n Queues

Ryan Farney — Fri, 21 Sep 2018 20:46:43 +0000

Hey guys! This week I wanted to keep on the trend of covering some Data Structures in JavaScript as I got some good feedback on my last post. Last week we covered Linked Lists, which you can find here.

I believe Stacks and Queues are some of the more straightforward data structures, so maybe I should have led with these. Nonetheless, lets define them, walk through an example of creating them, and take a surface look at a practical case.

Queues

A queue can be thought of as a container where data goes in one side and out the other. I would say it is very similar to a lunch line. You get in the line and you will stay in that spot as the line moves forward, until you are done and leave the line… they say it is FIFO or “First In First Out”. The first record that goes into the queue will also be the first record out. Here, there is no idea of skipping or cutting the line. So, a Queue functions in this way. You can add records to the front and remove records from the back.

In JS when we want to implement a queue we usually use an array that we can restrict to just being able to add or remove elements. Why would we purposefully handicap this array to only being able to add an element to the front of the line and remove an element from the back? In a practical setting, I would say that it mainly comes down to writing clear code, so that another engineer does not misinterpret your algorithm and think they can manipulate it like any other array. But, it is more common to see queue questions in an interview.

Getting closer to writing some code, let’s think about how we would manipulate an array to add the first element and remove the last one. Well, we are in luck because there are array methods for that… QUEUE (we all knew it was coming) Array.unshift() and Array.pop(). If you’re unaware of what they do exactly, please refer to the docs linked. But, if you want to trust me, unshift will add an element to the front of an array and pop will remove the last element.

Let’s make a Queue from scratch.

We will start by creating out Queue and setting it's inner data to an array.


function Queue() {
  this.data = []
}

We will then work on our add function. Here we will simply add an element to the beginning of the queue with .unshift.

Queue.prototype.add = function(element) {
  this.data.unshift(element)
}

Finally, let's remove the last element from the queue using .pop.

Queue.prototype.remove = function() {
  return this.data.pop()
}

Stacks

A stack is very very similar to a queue. So, much of the same from above applies. You are still dealing with an ordered list of records, only this time it is FILO or “First In Last Out”. I would think about this as a stack of plates. When you stack plates one by one, the first plate ends up being at the bottom of the stack. So, if you want to get that first plate again, you have to remove every plate off of the top of the stack one by one until you are back to that first plate again.

Again, as we approach implementing our own stack, let’s think about how we would manipulate an array to look like what we described above. There are some more methods in mind for sure. How about we use Array.push() to add a record to the stack, Array.pop() again to remove the top record, and to return the top record without popping it we will need to create out own solution.

Just like as we did above, we will start off by defining our stack as having an empty array of data.

function Stack() {
  this.data = []
}

Now, we want to be able to add an element to the end of the stack instead of the beginning, so we use .push.

Stack.prototype.add = function(element) {
  return this.data.push(element)
}

When we remove an element, we still want to remove the "top" or last element, so we can use .pop again!

Stack.prototype.remove = function() {
  return this.data.pop()
}

And finally, if we want to be able to see what is on the top of the stack, we can peek at our stack.

Stack.prototype.peek = function() {
  return this.data[this.data.length - 1]
}

Practical Uses

It seems that interviews will, most often, be where you will encounter stacks and/or queues. However, a place that comes to mind where you see them both used is within the event loop. This is definitely not a topic to take a deep dive in right here, but it is also another common interview question. The event loop contains, the call STACK, the event table, and the event QUEUE. I wrote a blog a while ago called “Breaking Down the Call Stack” for a little more info on that, but I would also highly recommend you check out this article for more of a rundown on the event loop if you are curious.

Conclusion

Stacks n Queues are two very simple and similar data structures, the biggest difference being the way data is input into either, effecting how it is removed in the end.

Intro to Linked Lists in JS

Ryan Farney — Thu, 13 Sep 2018 01:05:44 +0000

Overview

"A linked list is an ordered collection of data. The collection contains a number of different nodes. Each node contains some amount of data along with a reference to the next node. When we put a handful of these nodes together we refer to it as a linked list as it literally is a list of nodes linked together. We will also frequently refer to it as a chain. The list of nodes that form the chain has an order that won’t suddenly or randomly change, unless we want to change it of course. In every Linked List there are two special nodes; the head and the tail. The head node is always the very first node of the list. The tail node is always the very last node of the list. The tail node can always be identified by the fact that it does not have a reference to ANY other node."

The data that can be contained in the node can be absolutely any data type we want; string, number, array, object, any type of JS value can be contained in these nodes. The other part of the node is a reference to the next node.

There are pro's and con's of using linked lists. Check out this Quora forum on it!

I believe the best way to learn Linked Lists (and most data structure/algorithm questions) is to actually practice them yourself. Pop open a repl and let's start by creating the most basic Linked List we can.

const nodeOne = {
  data: "Hi"
}

const nodeTwo = {
  data: "Sofia"
}

nodeOne.next = nodeTwo

console.log(nodeOne) // => { data: 'Hi', next: { data: 'Sofia' } }

Essentially, we have just created our very own linked list... I really encourage you to do it yourself and see how it works as we are going to get a bit deeper here.

As we said before, a linked list is made up of nodes. This sounds like something we can break out. So, let us create Node and LinkedList functions. But, before I write this out... think about what these functions might contain. Well, we know a node has it's data and a reference to the next node. AND (for starters) we know that a linked list has a head. Boom! Let's start right there.

function Node(data, next = null) {
  this.data = data,
  this.next = next
}

function LinkedList() {
  this.head = null
}

Now, let's experiment with our linked list a little bit and perform some actions on it. Here I am going to use Prototype Delegation. If you are not certain what that is, I would highly recommend diving into the pros, cons, and differences of class vs prototypal inheritance here at some other time, but don't worry... you can still follow along.

Also, I might add, there are plenty of ways to do this and if you do it another way I would love to hear why.

The first thing we want to be able to do is to add a node to the front of our list. At this point, I am assuming you are following along in a repl.

Let's create a function addToFront that sets the head of the linked list to our new node!

LinkedList.prototype.addToFront = function(data) {
  this.head = new Node(data, this.head)
}

let list = new LinkedList()
let node = new Node(5)
list.head = node
list.addToFront(10)
console.log(list) // => LinkedList { head: Node { data: 10, next: Node { data: 5, next: null } } }

// You should continuously be testing in your repl like above ^^

Now, maybe we want to check the size of our linked list. We can create a function called size that counts every node in our list!

LinkedList.prototype.size = function() {
  let counter = 0
  let node  = this.head

  while (node) {
    counter++;
    node = node.next
  }
  return counter
}

Notice we use a while loop here. This is a really nifty technique that will come in handy for a lot of the other problems. We set the counter and then the node variable to the first node. While there is a node in our list (or until node === null) we increase the counter while simultaneously resetting our node variable to the next node in the list. Finally we return the counter.

Maybe we want to have different functions that will retrieve the first and last nodes. So, we create retrieveFirst and retrieveLast functions. For the sake of space, retrieving the first node would just be returning this.head, so we will not write that out, but you should. However, for retrieveLast we will have to do something somewhat similar to our size function.

LinkedList.prototype.retrieveLast = function() {
  let node = this.head
  if (!node) {
    return null
  }

  while(node) {
    if (node.next === null) {
      return node
    }
      node = node.next
  }
}

All we are trying to do is to return the last node in our list... the tail. But, if there is no first node, we return null. If there is, we get into our while loop only this time we make sure to check if the next node is there. If there is no reference to the next node, we know we have hit the tail and we return it.

Maybe we want to delete our entire linked list all together, or at least clear it up. Let's create a method called erase. This is actually a lot easier than it may seem. We know that a linked list begins with a head, which references the next node and so on. What if we just cut the head off of the monster?! If there is no initial reference point for the linked list, then it will be gone. Try it out.

LinkedList.prototype.erase = function() {
  return this.head = null
}

On the same note, what if we wanted to just remove the first node/head?

First, we would want to check if there even is one to remove. Then we could just make that first node equal to the next one!

LinkedList.prototype.removeFirst = function() {
  if (!this.head) {
    return;
  }
  return this.head = this.head.next
}

We are rollin' now! How about a few slightly more difficult ones?

Let's delete the last node and let's also try to create a new tail node. To delete the last node we first need to take care of a few edge cases. 1) We want to make sure that there is a head node and 2) we want to make sure that if there is only one head node that we just return null. After that there are a few different ways to do it, but I will walk you through the one that makes the most sense to me.

LinkedList.prototype.deleteLast = function() {
  if (!this.head) {
    return;
  }

  if (!this.head.next) {
    return this.head = null
  }

  let previous = this.head
  while(previous) {
    let node = previous.next
    if (!node.next) {
      return previous.next = null
    }
    previous = previous.next
  }
}

After our checks, we are setting two variables; the previous node that starts at the head and the node that will always be in front of the previous one. We want to continue our loop while there is a node there and once the reference to next node is null we know we have reached the last node and we will want to delete that node.

Aaaand finally if we are going to delete the last node, we might as well be able to add to the last node as well. I'll show you one final wrinkle. Above we created a prototype delegation method called retrieveLast(). Let's make it easy on ourselves and use this to find the last node to add onto.

Also, we will need to create a new Node here as we are adding one on, so our function will take in data. We then will set our retrieveLast() function to a variable. Finally, we will want to make sure the linked list isn't empty. If it is, we will set the new node to be the head, if not, we set it to last.next.

LinkedList.prototype.insertLast = function(data) {
  const newNode = new Node(data)
  const last = this.retrieveLast()

  if (last) {
    last.next = newNode
  } else {
    this.head = newNode
  }
}

Conclusion

Thanks for following along! I hope this helped and that you learned a little bit about linked lists for starters :)!

References

Check this great course out!

MERN Stack Udemy Course Review

Ryan Farney — Mon, 10 Sep 2018 03:55:39 +0000

Background

About a year ago when I was at the very, very, very beginning of my journey to programming, I was doing plenty of research on a bunch of different paths to follow. I was leaning heavily towards doing a “bootcamp.” I even wrote my first Dev.to post back then asking for advice!

Naturally, while researching bootcamps I came across plenty of information about the stacks that individual ones teach and why it is important to look for the “right stack.” At the time, I had little knowledge of what a stack even was. So, one day I sat down and took down a short 6 pages of notes on all of the most popular tech stacks, their pros, their cons, and it seemed like what I was looking for pointed to learning either the MEAN or MERN stacks. If you are not familiar, these are MongoDB, Express, (Angular or React) and Node.js.

While, I was intrigued at learning one or both of these, for a number of reasons I will not get into I chose a program that did not use MongoDB, Express or Node.js.

After my program, however, I have been on a mission to pick up the MERN stack (as I already had experience in React). Queue the MERN Stack Udemy Course.

I know there are plenty of people who think tutorials and Udemy courses can hinder you or give you a one-dimensional approach to development. However, this course was amazing if you are looking to pick up the MERN stack. There is not a single detail that is left uncovered.

Review

Brad Traversy is a magnificent teacher and goes above and beyond in his explanations as he walks step by step through the build. The end product is a thought out social media site for developers. You can find mine here! Feel free to sign up if you want to check it all out and if you find any bugs let me know. It is not quite in the same league as Dev.to... so, no need to worry, Ben! It is pretty cool though if I do say so myself.

From picking up nifty tricks in VSCode to implementing Authorization and Authentication in Node along with a full explanation while adding Redux and THUNK into your app, this course covers it all. Brad showcased a ton of super usuful packages and even takes the time to walk you through bringing the application live on Heroku, which I had never done before.

This course is jam packed with information. So much so that you will not remember the entirety of what you went over. It is definitely fast-paced and requires a little experience. However, if you are like me and plan on going back over this course a few different times (it is super easy to navigate to specific spots), then I believe it is a great use of your money.

If you have some programming experience and are really interested in adding a working site to your portfolio, building a full-stack application from the ground up, and picking up the MERN stack I could not recommend this class more.

Udemy Recommendations?

I would love to hear if you enjoy taking Udemy courses and if so, which ones you would recommend as well. After finishing, I am in the market and am always hungry to learn something new ☺.

Leave any recommendations in the comments!

ngrok Use Cases and Quick Start Tutorial

Ryan Farney — Sat, 01 Sep 2018 07:25:56 +0000

Basically, ngrok allows you to take any project live without actually deploying it.

It is a simple concept and maybe that is not the best explanation, but here is what they say on their site.

What is ngrok?

“ngrok exposes local servers behind NATs and firewalls to the public internet over secure tunnels.”

How it works

“You download and run a program on your machine and provide it the port of a network service, usually a web server.

It connects to the ngrok cloud service which accepts traffic on a public address and relays that traffic through to the ngrok process running on your machine and then on to the local address you specified.”

I have been working part-time for an early stages startup in my first developer job. We are currently closing in on an MVP. I was on a call with our CTO last week and he introduced me to ngrok. I had never heard of it, but even using it minimally for the last week I can see SO many use cases for it.

I am sure there are other services just like it and maybe ones that you prefer over ngrok. I would love to hear about them if you want to leave a comment ☺.

For those of you who are unaware of what ngrok is and why you would need it, I will leave you a few use cases and do my best to give you a quick-start tutorial.

I would highly encourage you to go check out their site and play around with it a little bit here. Getting started is super straight forward using the command line tool, but I did run into one small issue when getting the server going which I will try to show below.

Use Cases

Demoing web sites without deploying
Building webhook consumers on your dev machine
Testing mobile apps connected to your locally running backend
Stable addresses for your connected devices that are deployed in the field
Running personal cloud services from your home
Easily check responsive design on your mobile device
[insert yours here]

Notable Features

Inspecting traffic on your site
Replaying site requests

Once you have ngrok installed and set up (to do this: create your account and immediately follow CLI instructions), here is a quick video rundown of how to get it going.

Excuse how choppy I am… it’s only my second tutorial video ever!!! But, I really felt that this was one of those things that can be better understood by actually getting to see it work. Hopefully, this gives you guys a good idea of how to get up and started with ngrok.

Enjoy!

I would love to hear any feedback you guys have on my video and blog! I know my terminal may have been a bit small and difficult to see. So, here is the command I used to get around the host header bug. Also, notice I am in the “~” directory.

./ngrok http 3000 -host-header="localhost:3000"

Conclusion

While I am just getting started with this tool, I can already see so many uses for it. I wanted to put this blog out there because ngrok was something I was completely unaware of. Even if it helps to make one person’s life a liiiiittle bit easier I have done my job. Thank you ☺

Intro to Recursion in JS

Ryan Farney — Sat, 25 Aug 2018 03:09:51 +0000

If you are just starting out in programming, you may have heard of this topic; Recursion. Personally, recursion is one of those programming concept’s that has taken me a long time to wrap my head around. Admittedly, I still have a ways to go but in my opinion, there are a few main reasons as to why this topic can be so fleeting.

1) You can solve any problem without Recursion, so it is often looked over for beginners.
2) It’s advantages are not super obvious.
3) It can be flat out confusing.

A good friend of mine once wrote, “Similar to a dictionary using a word to describe itself, it can be frustrating to comprehend. Recursion is unintuitive. When first introduced to recursion, programmers are typically reminded of the movie Inception.”

I may be shamed for this and I probably deserve it, but I am yet to watch Inception. It was just one of those things I never got around to… Maybe it’s why I’ve taken so long to figure the whole recursion thing out ><.

I would say that the main advantage of recursion is that for some longer problems it makes the algorithm a little more readable and elegant. However, for the most part recursion can be slower, and takes up more of the call stack as well.

Here’s a great article that explains some differences between recursive and iterative solutions!

Please bear with me as I take you through a few key terms and some basic problems to help you on your way to mastering the daunting topic of recursion.

Maybe I should have defined it earlier, but Recursion is a function that calls itself until a specified condition is met.

If we wanted to write a function that counted down from a number, we could do something like this.

function sayDownFrom(n){
    console.log(n)
    if(n > 1){
        sayDownFrom(n -1) // recursive call
    } else {
        return true // base case
    }
}

Here in the body of the function we see that the function actually calls itself. This is referred to as the recursive call. We can also see that the function has a stopping point, which can be referred to as the base case. Without a base case, we would end up in an infinite loop.

So, what is this function doing exactly?

Line by line…

function sayDownFrom(n){
    // we print the number first
    console.log(n)
    // then we check if n is greater than 1, which is essentially setting a counter to stop if it is less
    if(n > 1){
        // if n is greater than 1, we call our function which will print out the number before n (in essence, counting down)
        sayDownFrom(n -1) // recursive call
    } else {
        // if n is not greater than one it will go to our base case here and return true and complete the execution
        return true // base case
    }
}

Now, let’s go through a few more problems line by line to get some more experience and see if we can pick out any recurring themes in recursive solutions.

Let's write the classic isPalindrome solution recursively. Here we want to find if the string passed into our function is a palindrome... like "racecar" or "hannah".

function isPalindrome(str) {
    // setting a variable to the length of our string
    var strLen = str.length;

    //checking if the length is zero or if the length is 1
    if (strLen === 0 || strLen === 1) {
      //if we reach either of these cases we will want to return true because of our next 'if' statement
        return true;
    }

    if (str[0] === str[strLen - 1]) {
      // here we are checking if the first index in the string and the last index in the string are the same

      // if they are the same then we are going to make our recursive call, but this time pass in the string without the letters that we just checked for
      // hence the use of slice
        return isPalindrome( str.slice(1, strLen - 1) );
    }

    // if this last 'if' statement were to fail and neither of the first or last letters were equal to each other at any time in our functions life
    // then we would return false immediately since it would not pass the 'if' statement above
    return false;
}

We have looked at two solutions, one with an integer and one with a string. Let's throw one in with an array!

Let's write out a function to see if an array includes a given element.

function includesNumber(arr, element) {
  //if there are no more elements in the array, then we have checked them all and it is not there
  if (!arr.length) {
    // so we will return false
    return false

    // we are now checking if the first element is equal to the passed in element
  } else if (arr[0] === element) {
    // if it is we return true
    return true

    // if none of those things are true yet, we check the array without the first element that we had just checked
  } else {
    return includesNumber(arr.slice(1), element)
  }

Conclusion

We can see some patterns in these few simple problems, particularly our includesNumber and isPalindrome functions. In both we check for equivalents and use the .slice method. Just like anything in programming, you will find patterns the more that you practice. If you are practicing algorithms, I would always recommend finding the solution first (no matter how lengthy and ugly it is) and then refactoring from there (including thinking about or attempting the problem recursively).

Hopefully walking through a few problems has given you a general idea of a few things to look for and how to start thinking about recursive solutions. Cheers!

Array Chunking

Ryan Farney — Fri, 10 Aug 2018 06:02:02 +0000

By array chunking, I mean taking an entire array and creating one array containing smaller subarrays of the original array's elements. Not only is this a commonly asked concept on technical interviews, but I can also see how there may be use cases for it when ordering or organizing a dataset.

Here I will tackle a relatively simple "array chunking" problem and go through a few different ways of solving it. By no means are these the only ways of doing it!

Problem

Given an array and chunk size, divide the array into many subarrays where each subarray is of length size.

I believe conceptualizing this problem is easier when we can see some of the expected outputs...

chunk([1, 2, 3, 4], 2)  //→ [[1, 2], [3, 4]]
chunk([1, 2, 3, 4, 5], 2)  //→ [[1, 2], [3, 4], [5]]
chunk([1, 2, 3, 4, 5, 6, 7, 8], 3)  //→ [[1, 2, 3],  [4, 5,6], [7, 8]]
chunk([1, 2, 3, 4, 5], 4)  //→ [[1, 2, 3, 4], [5]]
chunk([1, 2, 3, 4, 5], 10)  //→ [[1, 2, 3, 4, 5]]

Here we can see that the "size" number is for how many elements are in each subarray. As we can see they are not always even, so we want to make sure that the extra elements in our original array will plug into a final and smaller subarray.

Alrighty! I will throw in line by line explanations, but... Let’s code already ☺.

First Solution

This is the solution that is likely a bit more evident, especially to somebody who is not as practiced in JavaScript. Orrrr maybe your interviewer asks you to solve the problem without a few of the fancier JS methods. You never know!

function chunk(array, size) {
  //declaring variable 'chunked' as an empty array
  let chunked = [];

  //for loop iterating through every element of our input array
  for (let ele of array) {
    //declaring variable 'last' as the last index of our 'chunked' array
    const last = chunked[chunked.length-1];

    //checking if last is undefined or if the last subarray is equal to the size
    if (!last || last.length === size) {
      //then we push the element to be a new subarray in 'chunked'
      chunked.push([ele])
    } else {
      //if not, then we add the element to the 'last' subarray
      last.push(ele)
    }
  }
  //return the array of subarrays
  return chunked
}

Second Solution

In this second solution (and probably the one that comes the most naturally to me) we make use of the .slice method. If you are unfamiliar, please reference the docs for .slice here! The key thing to remember here is that calling .slice will return a new array!

function chunk(array, size) {
  //declaring variable 'chunked' as an empty array
  let chunked = []

  //setting our start point for our while loop at index 0
  let i = 0;
  //looping through the array until we have reached the final index
  while (i < array.length) {
    //push the sliced subarray of length 'size' into our new 'chunked' array
    chunked.push(array.slice(i, i + size))
    //increment by the size as to avoid duplicates
    i += size;
  }
  //return the array of subarrays
  return chunked
}

Third Solution

This last solution is probably the fanciest (and shortest). Personally, I have not gotten super familiar with the .splice method, but I know it can occasionally lend itself handy in problems like these. Again, please reference the docs here! Specifically for this solution's needs, I would scroll down a bit to reference how it is used when removing elements... but it can also do a few other things. The key thing to remember here is that, unlike .slice, the .splice method mutates the original array!

function chunk(array, size) {
  //declaring variable 'chunked' as an empty array
  let chunked = []

  //looping through the array until it has been entirely "manipulated" or split into our subarrays
  while(array.length > 0) {
    //taking the spliced segments completely out of our original array
    //pushing these subarrays into our new "chunked" array
    chunked.push(array.splice(0, size))
  }
  //returning the new array of subarrays
  return chunked
}

Thanks For Stopping By!

Why Your Technical Blogs Belong On Dev.to

Ryan Farney — Thu, 02 Aug 2018 00:39:35 +0000

Coming to this post, I am assuming you already have a blog or are considering the possibility of starting one. Before you go any further, I want you to take a second and ask yourself what is your purpose behind the creation of your technical blog. Maybe it is because you are knowledgeable on a topic and want to spread your wisdom. Maybe it is because you have finally solved a problem that you could not find the answer to and are looking to help the next guy. Maybe you want to put yourself out there to help your career. Or maybe you just want your voice to be heard.

The list goes on for great reasons to begin a technical blog EVEN IF you are only a novice developer. Personally, I began my technical blog as a way to continue to learn and contribute to the tech community.

Whatever the reason, it is vital to understand that where you post your blog will have a major impact on your goals.

Personally, I have been writing technical blog posts for the last 6 months or so on Medium. You can find that here! I love the possibility that my experiences put into writing can have a positive impact on somebody. However, as I have recently finished Flatiron School and entered the job hunt, I now realize that this blog can also have a positive affect on my career.

Prior to this, I had been publishing my blogs on Medium. However, looking back I realize that this may have been a mistake. Here are the reasons why I have decided to make the switch to the Dev.to community and also why I encourage you to do so as well.

Technical Specific Blogs

One of the first things that comes to mind and something I love about publishing on Dev.to is that your blogs are written using Markdown Here. There is just a bunch of added functionality that makes your technical posts look cleaner and make more sense. I don’t want to go into it too much, but being able to essentially write code that looks clean within your blog is super neat.

var s = "JavaScript syntax highlighting";
alert(s);

Also, the ability to Preview your post before publishing is awesome to see how it looks with the Markdown.

Here is a link to a Markdown Cheatsheet to help you out!

Community

While Medium and other sites may have some sense of community, I am yet to find a developer community stronger than Dev.to. From the interactions I have had with The Practical Dev and Ben Halpern on Twitter, to the weekly newsletter I receive from Jess with featured stories, those who run the community create an easy-going environment that is fun and helpful to engage with. On top of that, the contributions on Dev.to are relevant and topical. I cannot count how many times I have found inspiration or an answer to a problem I have always had by simply scrolling through the feed.

Learning

As web developers it is our job to constantly stay in the know. While I initially began my blog to take deeper dives into topics that I had already known about, since joining Dev.to, I have been introduced to thousands more I never would have heard of. Whether it is seeing simple headlines of articles, going through a popular contributors posts, or scrolling the comments sections there is always something to pick up.

The feed that is deployed on the Dev.to community will increase the chances of your blog reaching an audience rather than being buried in the archives of Medium. The more exposure that your posts get, the more likely you will be to achieve the goal you started out with.

Welcoming to All Levels

Unfortunately, there are plenty of communities, particularly in tech, that are not as welcoming to beginners. I couldn’t count the number of times I have seen harsh and discouraging comments on blogs or questions posted in forums and communities. Speaking from experience, the belittling feeling is not only embarrassing, but can make somebody just starting out want to quit.

The people at Dev.to do an amazing job at encouraging an environment for all skillsets, levels and minds. In doing so, they bring passionate and compassionate developers to their platform. I do not want to put words in anybody’s mouth, but I firmly believe that these are values that are held high and made priorities for the community.

Career Notice

As we discussed above, the Dev.to community feed is an amazing to place to see posts by developers from all over the world. Being an active member in the tight-knit community does not go unnoticed. I have seen/heard of multiple cases where developers have been networked through the community and even ended up making a career move through the Dev network.

User Experience

Last, but definitely not least I am a huge fan of the experience you get on the site. From the simplistic interface to all of the necessary features surrounding the feed the layout is clean, organized and easy to navigate.

One of my favorite features is that you have the option of adding tags for posts that you are interested in. This means that the majority of the content you are seeing will be on topics that interest you. Not only does this help you learn, but it also makes it easier to engage with the community and others to engage with you.

Conclusion

From my experience it is an amazing idea to start a blog no matter where you do it. However, all of the reasons above and more are why contributing to the Dev.to community will maximize the potential of your blog and get you closer to your own goals. Thank you for reading and keep on blogging! Godspeed.

Recommended Bootcamps?

Ryan Farney — Fri, 07 Apr 2017 23:03:31 +0000

I graduated college in May with a degree in Marketing. Towards the end of my college career I was able to free up some time to take a few coding classes (something that I had been wanting to do for a while). I was able to finish with some work in HTML and a basic understanding of Python and Javascript. I became incredibly interested after the classes and since have been highly considering pursuing a career as a programmer.

Unfortunately, I am not exactly sure where to start. Many people recommend self-teaching and/or Bootcamps. Even when it comes to self teaching or simply practicing, I am unsure which languages are best to dive into/most relevant. I understand that much of it depends on what I am looking to do, but if there is any insight into specific languages that are good to begin with then I would love to hear.

I think a Bootcamp may be something that would benefit me most, but even then I am curious to hear thoughts on Bootcamps in general. Also, if you would recommend enrolling in a Bootcamp, which ones are the best and/or notoriously the worst?