resources – Crooked Code

Rubber Ducking and ‘You Don’t Know JS’

I’ve recently been working my way through the You Don’t Know JS books by Kyle Simpson. If you are learning JavaScript and haven’t taken a look at these books, uhhh, what are you waiting for??

“JavaScript sucks man….”

There are a lot of arguments out there as to why JavaScript is such a shitty programming language. Accompanying each of these arguments are books and blogs by authors that try to teach JavaScript in spite of it’s shittiness!!

“Uhhh, no, you just don’t get it…”

Kyle Simpson takes the opposite approach… As you can see in the Preface of his YDKJS series, his opinion is that JavaScript is a deep and rich language that few developers take the time to know properly. His argument is that when faced with an obstacle, many JS developers blame the language rather than their lack of understanding.

Now that sounds like someone I want to learn from! Taking this approach establishes a level of accountability and responsibility to one’s craft.

So when other authors are saying ‘JS is a shitty language, here’s how to get around it’s shittiness’, Kyle Simpson is saying ‘JS is a deep and powerful language, here’s how to embrace it and have it work for you.’

I’ve read three of the six YDKJS books completely and skimmed through the other three. There are some really difficult concepts covered that take a couple times reading through to fully grasp. Concepts like closures, modules, ‘this’, prototypes and async to name a few..

What’s the point of this post??

I plan on writing a series of blog posts that work through these concepts and explain them at a basic level. Do I think I can explain these better than the author? Absolutely not, so I encourage you to read the books (in addition to my blog, of course).

I am, however, doing this for two reasons.

First, obviously I’m far closer to a beginner than Kyle Simpson, which, believe it or not, can have it’s advantages when trying to explain complex concepts. It’s possible that I can word these concepts in a way that might be more relatable to someone just starting out. (I’m not saying it’s going to happen, just that it’s possible)

Second, it’s an exercise in rubber ducking.

rubberduck

And what the hell is Rubber Ducking??

If you haven’t heard the term, rubber ducking is a technique by which you try to understand something by explaining it to a rubber duck.

The theory is, in order to teach it to someone who has no previous understanding (i.e. the duck), you must completely understand the concept yourself! (if you haven’t noticed, I do a lot of rubber ducking here at Crooked Code)

So rather than just read through these books for a second time, I’m going to work through them and try to teach these concepts so they might be understood by a beginner.

Even if nobody reads or visits these posts, I will have gained a better grasp of the difficult parts of JavaScript by teaching them…

More rubber ducking posts to come, I hope you enjoy and get something out of them. That’s it for now…

-Jeremy

Embarrassingly Elaborate Solution to a Codewars Algorithm

I’ve been thinking about writing a post like this for a while but have put it off because, frankly, it’s pretty embarrassing…

Today, I saw a post in the Free Code Camp Forums that made it clear, however, that I’m not the only one that goes through this. So hopefully this post will encourage other beginners to keep going, even if their code looks terrible in their own eyes…

The purpose of this post won’t be to walk through the algorithms and explain everything that’s going on, but rather to emphasize how different two answers to the same problem can be.

Codewars

Codewars, as I’ve mentioned in previous posts, is a great way to practice solving algorithm challenges. It can be pretty humbling at times, though, because after you solve the problem, you have the opportunity to look at other people’s solutions.

So, when you solve what you thought was a difficult challenge, only to see that others have solved it in one or two lines of code, it makes you wonder if you’re writing in the same language. When you realize you are, you wonder further if this coding thing is really for you…

The upside to this, and, in my opinion, the real strength of Codewars, is that you can learn from these solutions… I’ve only done a handful of algorithms on this site so far, but I’m going to show my first and last solutions as examples of how things can improve.

My First Codewars Solution

The first algorithm I solved at Codewars was called ‘Decode the Morse code’. Try not to laugh….

The site’s description of the algorithm is as follows:

/*
In this kata you have to write a simple Morse code decoder. While the Morse code is now mostly superceded by voice and digital data communication channels, it still has its use in some applications around the world.

The Morse code encodes every character as a sequence of "dots" and "dashes". For example, the letter A is coded as ·−, letter Q is coded as −−·−, and digit 1 is coded as ·−−−. The Morse code is case-insensitive, traditionally capital letters are used. When the message is written in Morse code, a single space is used to separate the character codes and 3 spaces are used to separate words. For example, the message HEY JUDE in Morse code is ···· · −·−− ·−−− ··− −·· ·.

NOTE: Extra spaces before or after the code have no meaning and should be ignored.

In addition to letters, digits and some punctuation, there are some special service codes, the most notorious of those is the international distress signal SOS (that was first issued by Titanic), that is coded as ···−−−···. These special codes are treated as single special characters, and usually are transmitted as separate words.

Your task is to implement a function decodeMorse(morseCode), that would take the morse code as input and return a decoded human-readable string.

For example:

decodeMorse('.... . -.--   .--- ..- -.. .')
//should return "HEY JUDE"
The Morse code table is preloaded for you as MORSE_CODE dictionary, feel free to use it. In Java, the table can be accessed like this: MorseCode.get('.--'). In C#, the preloaded Dictionary can be accessed like this: MorseCode.Get('.--');.

All the test strings would contain valid Morse code, so you may skip checking for errors and exceptions.
In C#, tests will fail if the solution code throws an exception. Please keep that in mind. (This is mostly because else the engine would simply ignore the tests, resulting in a "valid" solution.)

Good luck!
*/

In this kata you have to write a simple Morse code decoder. While the Morse code is now mostly superceded by voice and digital data communication channels, it still has its use in some applications around the world.

The Morse code encodes every character as a sequence of "dots" and "dashes". For example, the letter A is coded as ·−, letter Q is coded as −−·−, and digit 1 is coded as ·−−−. The Morse code is case-insensitive, traditionally capital letters are used. When the message is written in Morse code, a single space is used to separate the character codes and 3 spaces are used to separate words. For example, the message HEY JUDE in Morse code is ···· · −·−− ·−−− ··− −·· ·.

NOTE: Extra spaces before or after the code have no meaning and should be ignored.

In addition to letters, digits and some punctuation, there are some special service codes, the most notorious of those is the international distress signal SOS (that was first issued by Titanic), that is coded as ···−−−···. These special codes are treated as single special characters, and usually are transmitted as separate words.

Your task is to implement a function decodeMorse(morseCode), that would take the morse code as input and return a decoded human-readable string.

For example:

decodeMorse('.... . -.-- .--- ..- -.. .')

//should return "HEY JUDE"

The Morse code table is preloaded for you as MORSE_CODE dictionary, feel free to use it. In Java, the table can be accessed like this: MorseCode.get('.--'). In C#, the preloaded Dictionary can be accessed like this: MorseCode.Get('.--');.

All the test strings would contain valid Morse code, so you may skip checking for errors and exceptions.

In C#, tests will fail if the solution code throws an exception. Please keep that in mind. (This is mostly because else the engine would simply ignore the tests, resulting in a "valid" solution.)

Good luck!

So, in thinking about the solution to this algorithm, I immediately pictured various ‘for’ loops to split the Morse code into words, then letters. Then I could replace the Morse letters for real letters and reassemble the message using more ‘for’ loops.

Here is what I came up with…

decodeMorse = function(morseCode){
         //accept morse code string as argument
 var str = arguments[0];
         //trim leading and trailing whitespace
 str = str.trim();
 
         //create 2d array by word then letter
 var arr = str.split('   ');
  
 for(var j = 0; j < arr.length; j++){
      arr[j] = arr[j].split(' ');
     }
    
          //loop through array exchanging morse code for letters
 for(var k = 0; k < arr.length; k++){  
      for(var i = 0; i < arr[k].length; i++){
          arr[k][i] = MORSE_CODE[arr[k][i]];
    }
  }
      
          //compress array into words and return
  for (var l = 0; l < arr.length; l++){
    arr[l] = arr[l].join('');
  }
  
  return arr.join(' ');
}

decodeMorse = function(morseCode){

//accept morse code string as argument

var str = arguments[0];

//trim leading and trailing whitespace

str = str.trim();

//create 2d array by word then letter

var arr = str.split(' ');

for(var j = 0; j < arr.length; j++){

arr[j] = arr[j].split(' ');

}

//loop through array exchanging morse code for letters

for(var k = 0; k < arr.length; k++){

for(var i = 0; i < arr[k].length; i++){

arr[k][i] = MORSE_CODE[arr[k][i]];

}

//compress array into words and return

for (var l = 0; l < arr.length; l++){

arr[l] = arr[l].join('');

}

return arr.join(' ');

}

I was feeling pretty good about myself (it worked after all!) until I saw some of the top rated solutions…

Here are a couple:

//by czyzykowski

decodeMorse = function(morseCode){
  function decodeMorseLetter(letter) {
    return MORSE_CODE[letter];
  }
  function decodeMorseWord(word) {
    return word.split(' ').map(decodeMorseLetter).join('');
  }
  return morseCode.trim().split('   ').map(decodeMorseWord).join(' ');
}

//by czyzykowski

decodeMorse = function(morseCode){

function decodeMorseLetter(letter) {

return MORSE_CODE[letter];

}

function decodeMorseWord(word) {

return word.split(' ').map(decodeMorseLetter).join('');

}

return morseCode.trim().split(' ').map(decodeMorseWord).join(' ');

}

//by Azuaron

decodeMorse = function(mc) {
  return mc.trim().split('   ').map(function(v) {return v.split(' ').map(function(w) {return MORSE_CODE[w];}).join('');}).join(' ');
};

//by Azuaron

decodeMorse = function(mc) {

return mc.trim().split(' ').map(function(v) {return v.split(' ').map(function(w) {return MORSE_CODE[w];}).join('');}).join(' ');

};

//by prettycoder

decodeMorse = function(morseCode){
  return morseCode.trim().split(' ').map(a => MORSE_CODE[a] || ' ').join('').replace(/\s+/g, ' ');
}

//by prettycoder

decodeMorse = function(morseCode){

return morseCode.trim().split(' ').map(a => MORSE_CODE[a] || ' ').join('').replace(/\s+/g, ' ');

}

Pretty big difference, huh? These 3 solutions, put together end to end, took fewer lines than my 1 solution did…

I want to make a couple points about this…

My Latest Codewars Solution

First, if you use these solutions to learn from, you can get more clever with your own solutions, and in the end, make yourself a better programmer.

Here’s an example of an algorithm I submitted a couple days ago.

Algorithm details:

/*
Write an algorithm that takes an array and moves all of the zeros to the end, preserving the order of the other elements.

moveZeros([false,1,0,1,2,0,1,3,"a"]) // returns[false,1,1,2,1,3,"a",0,0]
*/

Write an algorithm that takes an array and moves all of the zeros to the end, preserving the order of the other elements.

moveZeros([false,1,0,1,2,0,1,3,"a"]) // returns[false,1,1,2,1,3,"a",0,0]

My solution:

var moveZeros = function (arr) {

  var length = arr.length;
  var newArr = arr.filter(function(num){return num!==0});
    
  while(newArr.length < length){
    newArr.push(0);
  }
  
  return newArr;
  
 }

var moveZeros = function (arr) {

var length = arr.length;

var newArr = arr.filter(function(num){return num!==0});

while(newArr.length < length){

newArr.push(0);

}

return newArr;

}

Most of the top solutions were variations of this:

var moveZeros = function (arr) {
  return arr.filter(function(x) {return x !== 0}).concat(arr.filter(function(x) {return x === 0;}));
}

var moveZeros = function (arr) {

return arr.filter(function(x) {return x !== 0}).concat(arr.filter(function(x) {return x === 0;}));

}

Ok, so was this last attempt better?? Sure… Still room for improvement? You betcha…

Looking through past examples definitely helped me put together a more concise solution for this problem, but I still have a lot to learn…

For instance, looking at the answers to this algorithm reminded me that the array.filter() method doesn’t change the array on which it is called. So, once I filtered the non-zero values into a new array, I still had the original array to work with. I could have used it again to add the zeros to the end of the new array.

Hopefully, next time I come across a problem like this I’ll remember the more elegant solution.

In my experience, learning a new skill, especially one as difficult as programming, is all about repetition and practice. So I encourage you (and myself too) to use sites like Codewars to practice these skills over and over.

I also encourage you to take the time to look through other people’s solutions and learn from them. It’ll probably help with your approach to your next one.

It ain’t necessarily about having the shortest solution…

The second point I want to make is that the shortest solution isn’t necessarily the best solution.

We can argue that ‘for’ loops are actually faster than native functions like array.filter() and array.map(), and they are, but that argument is mostly semantic. Unless you are writing an application that demands extremely high performance, it is unlikely that the user will see a difference between the two.

I believe, therefore, that prioritization should be placed on the readability of the code you write.

Going through the process of teaching myself how to code, I’ve read many examples of code written by others, and can say for certain that all code is not created equal.

Some code is nicely written and readable… Other code is like a plate of spaghetti and impossible to decipher.

Let’s go back to the answers to the first algorithm. My code, while drawn out and overly complicated, is fairly easy to follow. The last two solutions listed, while being the shortest, are not that easy to read (at least to a newbie like me).

I’d argue that there’s gotta be a happy medium, maybe something like the one written by czyzykowski. Their solution is logical, modular and very easy to follow.

Feel free to comment below if you disagree, like I said, I’m still new to this, so maybe those last 2 examples are perfectly readable to someone who’s been at this a while.

Bottom Line

I think the takeaway from all this should be – don’t worry if your code looks like a fanewgi wrote it, just keep plugging away…

Read code others have written and keep writing more of your own. Before you know it, you’ll look back at code you wrote a while ago and realize just how far you’ve come!!

That’s it for now, I hope this helped straighten out the code…

-Jeremy

End of Summer Wrap-Up

It’s been a couple weeks since I’ve had the chance to write a post, as things have been a little crazy around the Crooked Code household…

Football season started for my two boys, they started school this week and my wife went back to work this week!! Hopefully, now things will start to settle down a bit.

Anyway, enough about that, let’s talk about what we’ve accomplished this summer and what we want to accomplish this fall….

What I’ve done this summer…

As I mentioned in a previous post, I finished the front end certificate at Free Code Camp in July!!

I decided to work on the Back End Program at FCC, then jump back and complete Data Visualization. Thus far, the back end has been difficult, but enjoyable.

It’s been difficult in that I’ve really had to change gears in my head. Node.js and working on the server side have been completely different than any other coding I’ve done in the past (granted, it’s a fairly limited past as far as coding is concerned).

Diving In…

I started the back end program by working through the Cloud9 modules for Git, Node.js, Express.js and MongoDB.

If I’m being honest, I found these modules to be pretty useless… I didn’t learn much from them, and half the time I wasn’t even sure what they were asking me to do.

As a beginner, I think it would have been more useful to have a better intro to the languages and better explanations as to what I was trying to do with them.

Instead, I felt like I was trying to satisfy the requirements of some very random modules so I could move on (and getting nothing out of it in return)…

I realize, that’s just my personal opinion and that different people learn by different methods…

Intro to the very helpful Ninja!

Speaking of actually learning, I found a very helpful tutorial series on YouTube called Node JS Tuturial for Beginners by the Net Ninja. I may have mentioned this guy before and I highly recommend these videos if your starting out learning the back end.

There are quite a few videos in the series, but each one is short and to the point and very easy to understand. I watched each of the videos and worked along side them in building a ‘To Do’ app in the last 7 or 8 videos.

In addition to a great intro into Node.js, one of the cool tangential things I learned from this series was working with Atom.

The ‘Ninja’ takes you through the steps of setting up Atom, installing Node, npm, etc. I’ve been working in Atom ever since and find it a much better environment to develop the back end projects than working on Cloud9.

Initial Thoughts on Server Side

At the risk of sounding a little naive and corny, learning how servers work has opened my eyes to the potential you have as a full stack developer.

Let me try to explain what I mean…

I feel like I learned a ton in the Front End program but I always had a nagging in the back of my head like, ‘yeah, these new skills are great, but how do I actually use this to build something bigger than a one page app??’.

Working with Node and Mongo and everything else involved in the back end program (yes, even Git) has calmed that nagging a bit and given me a sense of the bigger picture.

Granted, I’m less than a month into this and have a lot of work ahead of me, but it’s very motivating to start tying things together like this…

Progress Thus Far..

At this point, in addition to the Cloud9 ‘learning’ modules, I’ve completed 3 of the 5 API projects. Feel free to check out my Timestamp Microservice, Request Header Parser Microservice and URL Shortener Microservice.

You can find the code for all these apps on my GitHub page. Please feel free to comment below with any suggestions or questions about my code.

Where we’re heading this fall…

First and foremost, I’ll be working towards completion of the Back End Certificate. I plan on finishing up the last two API projects then moving right on to the full stack ‘Dynamic Web Application Projects’.

Additional Resources

In addition to the Free Code Camp projects, I’ve continued listening to tech related podcasts. I mentioned most of the ones I’m listening to in a previous post, but have picked up a few new ones as well.

Two of my favorite new ones are FiveThirtyEight Elections Podcast and IoT Podcast.

The Elections Podcast is by the awesome people at FiveThirtyEight.com where they talk about how they are applying their models in an attempt to predict the outcome of this year’s US presidential elections. It’s very relevant and very cool…

Internet of things

As I’ve been working through the back end program at FCC, I’ve been trying to think of ways to start applying what I’m learning in the real world.

One idea that I’ve been giving a lot of thought to lately is the internet of things (hence the IoT Podcast).

The internet of things, if you don’t already know, is a broad term that describes all the real word items (refrigerators, cars, wearables, thermostats, etc, etc, etc) that are hooked up to the internet and can be sensed and/or controlled remotely, the so called ‘smart’ items.

Just yesterday I ordered a beginners kit that includes a board and a bunch of sensors and motors so I can start playing around with this stuff. I’m really excited about it and one of my sons wants to get involved too, which makes it even better!

Johnny-Five!

Considering the FCC program is full stack JavaScript, I’m planning on using the JavaScript framework called Johnny-Five which enables you to run full stack JavaScript, including Node, to control the robotics. I’ll be sure to include my experiences here at Crooked Code.

A friend of mine, Serg Chernata, just started a blog called ‘Bits & Pieces‘, where he’s going to discuss a bunch of tech related topics, including his experiences with IoT. In fact, his first post was about setting up a Raspberry Pi as a home server to host his blog.

I’ve included a link to his blog on the sidebar of this site under ‘Recommended Blogs’. I’ll keep adding to this list as I come across sites that I find interesting and useful.

Once again I’ve written a much longer post than originally planned, which is not easy for someone who says so little in the real world! Hopefully, if you’re still reading, you got something out of this.

Until next time…

-Jeremy

Front End Certificate at Free Code Camp – Complete!!

Five months and one day after I discovered Free Code Camp, I’ve completed my Front End Certificate.

frontEndCert

It took a little longer than I had originally planned, but considering that in addition to learning HTML, CSS and JavaScript from scratch, I maintained a full time job and tried to spend (at least some) time with my family (including coaching a season of baseball), I’m pretty happy with the accomplishment.

A couple thoughts on the process….

When I discovered Free Code Camp, I rolled up my sleeves and began the front end development section with tunnel vision, focused only on completing the certificate. Along the way, my focus broadened… I began to realize that this process isn’t just about completing a certificate, but becoming a strong developer.

To that end, I searched for additional resources to supplement the Free Code Camp curriculum. I covered a lot of these resources in a previous post, but mostly it involved listening to podcasts, reading books, watching YouTube videos and practicing algorithms.

I also started this blog. If you would have told me before I started this process that I would start a blog on learning to code, I would have labeled you crazy…

I’m an introverted guy and generally keep my thoughts to myself, so expressing myself in these posts isn’t exactly second nature. I think, however, that doing so has significantly enhanced what I’m getting from this process (and hopefully helped at least a couple others in return).

I’ve also found that trying to explain the solution to an algorithm is, in many ways, much harder than writing the solution itself! I think this has certainly helped strengthen my coding skills and plan to continue working through the solutions to many of the freeCodeCamp algorithms and projects here at crookedCode.

So, if you find yourself getting frustrated with your progress in your own learning to code journey, take a step back and ask yourself what else you could be doing to broaden your learning experience.

And finally, I want to say – Learning to code is hard!

This journey has been difficult in many ways I could not have predicted at the onset. First, of course, learning a new skill (any new skill) can be difficult. Coding is certainly no exception, in fact, I’d argue just the opposite.

I feel the difficulty is often overlooked in the many articles (at least the ones I’ve read) that proclaim everyone can learn to code. Many of these articles fail to mention that it’s going to take a lot of work and a lot of extremely frustrating, trying moments, especially if you’re teaching yourself.

I’m not arguing against the idea that people should learn to code… If learning to code interests you, then by all means, let nothing stand in your way. Before you start, however, make sure that it’s something you really want to do and make sure you’re prepared to commit the time and mental energy to accomplish your goal.

In addition to the difficulty inherent to learning to code, many other aspects of the journey add to the difficulty…

Time management has been a big one for me. Keeping a full time job, having a wife and two active sons and learning to code is a very full plate. Through most of baseball season, I just coded whenever I could fit it in the schedule…

It seemed like there was something going on every night and throughout the weekend, so whenever there was a break, I would try to put some work in. I’ve got to say though, that pace is unsustainable if you value your mental health and the happiness of your family.

Since baseball has finished, I have blocked off two evenings and one day on the weekend that I devote to learning to code. Everything else (at least when I’m not at my full time job) can be spent with family or catching up with stuff around the house.

If you are learning to code and have other personal commitments, I highly recommend blocking off a schedule of when you plan to work. Otherwise, you always feel like you should be working and everything else in your life takes a back seat, and suffers because of it….

Of course, there are other things like maintaining self-confidence, battling impostor syndrome, deciding what to learn, setting up a development environment, etc., etc. but this post is already longer than I had planned. Just know that if you are struggling in your journey to learn to code, you are not alone, there are plenty of us out there in the same boat.

So, if you’re still reading this, thank you and good luck on your own journey. I’ll keep posting here at crookedCode to try to make things easier for those that actually read it. As for right now, I’m off to start the back end development certificate at Free Code Camp…

-Jeremy

My Learn-to-Code Journey: 3 months in…

I started my learn to code journey in late February, 2016, when I signed up for freeCodeCamp. So it’s been about 3 1/2 months and I figured this was as good a time as any to share my thoughts, progress, tools that I’ve found valuable, etc, etc.

First, a little background on what led me to this journey…

I’ve been doing drug discovery/pharmaceutical research for nearly 20 years. Last year, I found out that my job was moving to a different part of the country and for many reasons, not the least of which was apprehension over relocating my two sons, we decided not to make the move.

After a lot of soul searching (and driving my wife crazy), I decided to shift my career and learn to code. In fact, the real light bulb moment was reading Derek Sivers post ‘Should you learn programming? Yes.’ It’s where I discovered freeCodeCamp and everything seemed to snowball from there…

Stumbling on that Sivers post was just what I needed and I’ve since become a huge fan of his. If you haven’t read or watched anything by Derek, do yourself a favor and check out his site. He has a unique perspective on life that’s completely refreshing when compared to most of what you encounter in the world today.

Ok, enough background…

Looking back at the last 3 months, it’s hard to put into words everything I’ve gone through in learning to code. So far the journey has been fun, frustrating, time consuming, enlightening, tiring, exciting, stressful, rewarding, humbling… Basically, it’s been a roller coaster ride.

It seems like one minute I feel like I’m on top of the world and that I can do and create anything. Then the next minute I feel like a total idiot and don’t know anything. Then genius again, then an even bigger idiot than before… You get the picture.

Free Code Camp Update

For the time being, I still have a full time job (and coach my son’s baseball team) so I don’t have as much time as I’d like to devote to coding. I’ve put in a lot of late nights and weekends and, despite the two huge time commitments mentioned previously, feel like I’ve been able to make a ton of progress.

I’m nearing completion on the Front End Development Certificate at freeCodeCamp. I’ve completed all of the Algorithm Scripting Challenges and most of the Development Projects. The only projects that I have left are to finish my Tic Tac Toe game, then build a Pomodoro Clock and a Simon game. These, obviously, will take some time, but I should get them done within the next month or so. You can check out my projects on my Codepen page.

I’ve also started on the Back End Development Certificate. The first lesson was on Git, then you get right in to Node.js and Express.js. The biggest thing I’ve learned so far on the back end (in addition to reinforcing once again that I’m an idiot) is that I need to become comfortable in the command line.

Thoughts on Free Code Camp thus far..

I feel that freeCodeCamp, in providing projects with increasing levels of difficulty, provides a great path to follow in learning to code. On the other hand, I feel some of the learning modules are lacking. For instance, having gone through the git and npm learning modules at the beginning of the back end certificate, I don’t feel like I learned much and have little more understanding of how to use them now than when I started.

I don’t think, however, this is a negative for freeCodeCamp (and not sure if it was purposefully constructed this way or not). After all, what is the purpose of freeCodeCamp?? To prepare you to become an employable full stack web developer?

Part of this whole process is learning to become resourceful and knowing where and how to look for answers when you run into problems. Something at which I’ve become increasingly skilled. Is it frustrating to pause in the middle of a project to go look up how to code something? Absolutely. Over and over again? Yup… But in the end, I’ll be a much stronger programmer for it.

In addition to Free Code Camp

In a previous post, I mentioned some of the resources I’ve been using as I make my way through the front end cert at FCC. In addition to these, I’ve been broadening my knowledge of software development in general through the use of other sites, listening to podcasts and constantly searching for ways to learn (including starting a blog!!).

One of the other sites I discovered is Codewars.

Having finished all 3 algorithm sections at FCC, I was looking for a way to further my algorithm solving skills. I haven’t used the site extensively yet, in fact, I’ve only worked through about 4 or 5 ‘kata’ (which is what Codewars calls their algorithm problems), but I plan on going back on a fairly regular basis to stay fresh with Javascript as I work through the backend at FCC.

After you solve a given ‘kata’ , you can see the solutions of previous users. In fact, I’m planning on writing one of my next posts on an embarrassingly long solution I wrote that others had solved in one line. Ha! Live and learn I guess…

Like I said before, I’ve also gotten in the habit of listening to podcasts on my commute to and from work.

Some of my favorites, in no particular order are: JavaScript Jabber, CodeNewbie, Coder Radio, Eat Sleep Code, Becoming a Data Scientist, CodePen Radio, Simple Programmer, Software Engineering Daily and anyone that interviews either Seth Godin or Derek Sivers (The Tim Ferriss Show has great interviews of them both).

More Learning Tools

As I said before, I’ve used a lot of the tech websites (Mozilla, Stack Overflow, W3schools, etc) to learn as I went through the Front End course. I’ve decided to try something different on the back end. I signed up to audit a Node.js course on coursera. I can’t give any feedback on how useful the course is or whether it will help with the back end cert at FCC, as I just signed up for it yesterday, but I’ll be sure to write a future post about it.

While listening to the tech podcasts mentioned above, I kept hearing, over and over, the advice to create a blog. So I did… And I’m happy I did.

I have no idea how many people this blog will reach in the end, but one of the great benefits of it has been in reinforcing everything I’ve been learning. I know one of the best ways to really learn something is to try to teach it to others, but I didn’t realize just how true this was.

Even in writing a post about the solution to a Basic Algorithm Scripting challenge, I’ve really had to solidify my knowledge of the JavaScript language and understand the methods and data types that I’ve used. So, if you want to check if you really understand something, try explaining it to someone else…

As for advice on creating the blog itself, Simple Programmer (John Sonmez) created a great, and free, blogging course that walks you through the steps of creating a blog. If you’re considering creating your own blog, I recommend signing up for his course, it’s what I used to get started.

Damn this is post is long…

On the remote chance that anyone has stumbled on this blog, and on the even more remote chance that you’re still reading, let me leave you with this..

If you’re on your own journey in learning to code, you are going to go through some rough patches and getting though those times are going to be extremely difficult. My advice is this… Don’t take the easy way out, it’ll just lead to more rough patches.

What I mean by that is if you are looking to solve problem x, or write some code to accomplish y, the easy way would be to google it, find some code that someone else has written, copy and paste it into your project and move on… This may solve your short-term problem, but will get you nowhere in the end.

I’m not saying don’t use google to solve problems or look up ways to write something in whatever language you are using at the time. I do that all the time. What I am saying is take the time to learn how the code is written, or the logic behind the algorithm and go write your own solution…

That’s all for now, I’m off to continue my journey…

-Jeremy

Intro to JavaScript Terms

As a primer to more in depth JavaScript discussions, I figured an intro to some of the terminology that we’ll be using might be helpful. As this will not be a complete “Intro to JavaScript” (far from it, in fact), I’ll provide links to resources that I’ve found helpful along the way.

Resources

There are several sites that I use frequently in learning to code. Obviously, freeCodeCamp is the main one. As I mentioned in my first post, I am currently working through the front end development certification at freeCodeCamp and highly recommend it. While working through the freeCodeCamp curriculum I use w3schools, MDN and Stack Overflow extensively as references. I also found that Tutorial Republic is an excellent resource for HTML, CSS and Bootstrap (which is a powerful front end framework that makes creating responsive web pages much easier).

There are also a couple books that I’ve used along the way. The first is ‘Eloquent JavaScript‘, which is an excellent free resource (available in print also) for learning JavaScript. It’s not exactly a book for beginners, but the online version provides examples and problems that you can work through right in the browser. It’s the best JavaScript resource I’ve found yet… I also picked up the Head First books ‘HTLM and CSS‘ and ‘HTML5 Programming‘. They’re more on the beginner side, but are written well and I found them helpful in learning to interact with the DOM (which we will get into in future posts).

Intro to Terminology

Now, to cover some terms we’ll be using frequently. In future posts, I will have to assume a basic understanding of these languages, otherwise each post will be the length of a book. So I urge you, if you have any questions about the concepts listed below, please use the resources listed above to read more about them.

In JavaScript, groups of data are called values and these values have types. There are 7 data types in JavaScript:

undefined
null
boolean
string
symbol
number
object

Any of these data types can be stored in a variable. To declare a variable, use the keyword ‘var’, as such:

var a;  //a is an undefined variable

1	var a; //a is an undefined variable

The above statement created a variable named ‘a’. It also includes a comment… Anything written on a line after // is a comment and will be ignored by the browser. You can also assign values to the variable when you create it. The following statements create variables and assign values of the various data types.

var num = 1;          //type number
var x = null;         //type null
var bool = true;      //type boolean
var str = 'text';     //type string
var sym = Symbol();   //type symbol
var obj = {};         //type object
var arr = [];         //arr is now an empty array which is type object

var num = 1; //type number

var x = null; //type null

var bool = true; //type boolean

var str = 'text'; //type string

var sym = Symbol(); //type symbol

var obj = {}; //type object

var arr = []; //arr is now an empty array which is type object

JavaScript provides several data structures called objects and arrays. I plan on covering objects and arrays in depth in decipheredCode so for now will only cover each at a very high level.

Objects allow us to group data of various types (including other objects) as name:value pairs called properties. Objects are used extensively in JavaScript, in fact JSON (JavaScript Object Notation) files are the way most programs pass data among themselves over the web.

An array is a list of objects or values, called elements, stored inside brackets and separated by commas. Array elements can be accessed using bracket notation and indexes (note: first element in an array is index [0]). An example of accessing the first element of an array would be:

arr[0] = 'apple';

1	arr[0] = 'apple';

The arr declared above would now have the string ‘apple’ as it’s first element (index [0]). Chapter 4 of ‘Eloquent JavaScript’ gives a great explanation in the use of objects and arrays.

Another term used extensively in JavaScript, and programming in general, is function. A function is a self contained block of code that can act on it’s own to do something. A function can take a set of parameters (optional) and contains a block of code to act on those parameters. Here’s an example of a function.

function addOne(num){
var newNum;
newNum = num + 1;
return newNum;
}

function addOne(num){

var newNum;

newNum = num + 1;

return newNum;

}

This function, named addOne, has one parameter (num). The code inside the function creates a new variable called newNum, then sets newNum equal to num + 1 and returns the value of newNum. The way we would use this function (or invoke it) is

addOne(5);

1	addOne(5);

This example calls the addOne function and passes the number 5 as an argument. This function call would return the value 6.

What is an argument? An argument is the actual value that you pass into the function, as opposed to a parameter, which is the name listed in the function definition. I’ll be using these terms interchangeably here at decipheredCode (whether right or wrong…), so you can think of both arguments and parameters as something that gets passed into a function.

Now… This has been a long, rambling post that mentioned a bunch of things but didn’t really explain anything in detail. I feel, however, that it was necessary before I started digging any deeper.. Hopefully, this will be helpful to someone just starting out on their journey to learn to code. The next posts here at decipheredCode will start to dig into real problems. Meantime, I urge anyone that is interested to check out the links that I mentioned above and to start getting their hands dirty by writing some code!

-Jeremy