Language++

my journey to becoming a web developer in the SF Bay Area

[davidmcafee]

-10 days until I start App Academy

Finished just about all of the prep work once again, including a more expanded version of Battleship than I did last time.

Began working on a program that can walk through a maze, but it’s showing me that I haven’t quite gotten a handle on how exactly to BEST use recursion. The good news is that it finds the end of the maze! However, my solution doesn’t exactly print a straight line to the solution, instead, it zig zags it’s way through every open space, and prints out lines to dead ends. I have yet to find the best way to decide what direction to go in, and how to ignore paths to a dead end. After several hours of working on it, I’m happy with the level of effort I’ve put into it, so I feel like I can begin to do some research and then get back to it.

[davidmcafee]

-13

Going through the prep work a second time, I feel tremendously relieved. On my first pass through, I’ll admit the problems usually took me much longer than the expected 3 hours per day. But this time through, the concepts in no way feel over my head. Ofcourse, I’ve solved them all before, but the initial confusion I had about how classes interact, how exactly instance variables are instantiated and called, how to understand an RSPEC test, all seem very accessible to me.

How to best design a program, what objects to give what functionality to, still seems surprising to me when I read the RSPEC tests, but I’m hoping that the more I come in contact with well written classes, the sooner I’ll be writing them myself.

I’m still struggling through writing my own permutations solution, and though it’s frustrating me now, it seems like it wasn’t that long ago that I was struggling to understand how to reverse an array, which seems quite silly to me now.

I also made use of the colorize gem to make my console games at least a bit more interesting.

[davidmcafee]

-18 (returning back to the App Academy prep work)

I decided today to start going through the App Academy prep work for a second time. I’m tempted to just read through my old work, except as has been proven to me so many times, the best way to learn to program is to write code. So to reinforce the material, I’m doing the assignments a second time.

Maybe it’s just me, but I always have gotten tripped up on the terms FIFO and LIFO. Similarly, here and there I notice FILO and LILO, but those seem perhaps less used, so until I find a use for their definitions, I’ll just stick with the first two.

If I had to give the most basic descriptions with the most basic examples for these terms, here’s what I would use:

Queue: First In First Out (FIFO): The first object that enters a queue (enters from the front) is the first object to leave the queue (exits from the back). Think: Conveyer belt.

Stack: Last In First Out (LIFO): The last object that enters a stack (enters the stack from the top/back) is the first object to leave the stack (leaves from the top/back). Think: Packing and unpacking a shipping box.

Surprisingly, I just learned that ruby has some handy (almost) synonyms for &&, ||, and !: in order, ‘and’, ‘or’, and ‘not’. The only problem, however, seems to be that the originals have higher precedence. Oh well.

Lastly, if you are learning about Procs and Blocks, or could use a refresher, this chapter from Chris Pine’s book has some really great examples that make you really think about just how these guys really work.

[davidmcafee]

-19 (js intro complete)

The days seem to be flying by as I continue to prepare for my time at App Academy. It seems like it’s actually been quite some time since I finished the official prep work, but now that I’m (just recently) finished with Codecademy’s intro course to JavaScript, I’ll begin reviewing the official prep work and maybe even tackling some of the problems a second time.

[davidmcafee]

-24

Began today watching an App Academy instructor going through a practice assessment, guiding his development based on supplied RSpec tests. It was really helpful to watch his problem solving strategy as he went through it.

Had an introduction to Big O, which was slightly overwhelming but really informative.

I also have seen the idea of the “path variable” or “$PATH” thrown around a lot, especially during setup and installation instructions, but never understood what on earth it was. Here (http://stackoverflow.com/questions/18409707/what-is-path-on-the-mac-unix-system) is I think a fairly simple intro to what it is.

Also had a fair share of study breaks with my friend’s addicting new game.

[davidmcafee]

-25

Started off with some reading on code design, OOP, and that sort of thing. Reintroduced to UML, which I had heard of and been vaguely exposed to in the classes I took last year.

I also practiced several coding challenges on Code Wars.

I also spent time better understanding RSpec. Up until now, I had run RSpec tests, and had been given them as guides for homework, but I hadn't learned enough about them to write them myself, or to understand just how they worked. After completing all the readings, I felt like I had been exposed to so much new information that it would really help if I came back to it again, which I will probably do tomorrow.

[davidmcafee]

-26

Learned more about the stack and Ruby’s limits on stack frames, did a review of git, learned about data structures including a decent look at trees, and the two algorithms for searching them.

Completed a few exercises, including an implementation of quick sort, and a few recursion problems.

Next I did some readings on inheritance, and exceptions / error handling,

[davidmcafee]

-27

Today ended my wife’s summer break, and so begins my next several weeks of very intense preparation before I begin App Academy.

I started off by working quickly through the App Academy curriculum on github. I always learn best by being exposed to material several times, over time, so I figured it would be best to start looking ahead as much as possible. Since there is several weeks of material, I don’t plan to do all the exercises, and I plan to work fast (part of being able to work in an intense and fast-paced environment is practice, so I figured I should begin practicing just that). I figure it’s best to place myself into a timed, fast-paced context on my own, because a huge part of learning is learning to learn.

Today involved going over the basics once more, including coding style and debugging. I was very surprised to learn that Byebug can be used as a conditional debugger—super helpful if a method is called several times in your program, and you need to see which call is causing a problem.

Also reviewed the uses of the splat operator in Ruby, and watched some videos on recursion.

[davidmcafee]

-43

Finished blog comments feature for blog tutorial, and began working on adding tags.

I also restarted the codacademy JavaScript track, which I’m looking forward to because my current exposure to JS is incredibly minimal.

[davidmcafee]

-49

Today I decided to tackle understanding the quicksort algorithm. I’ve never been exposed to quicksort before, so finding a decent explanation was a bit challenging at first. I wasn’t exactly interested in the code just yet, but first at understanding the logic and design behind the algorithm itself. I stumbled upon this interactive demonstration, which gave me a good introduction to the concept.  If you are looking to get the “big picture” of how the sorting algorithm works, wikipedia also has this great chart that, in one image, shows how the quick sort algorithm works. Note: the way this algorithm is implemented always chooses the right-most element as the pivot - other implementations choose a random pivot.

Lastly, to see an implementation of the quicksort with ruby, check out this video. If you’d like to try out the code yourself to see how it works, copy and paste the code below into your text editor, comment out the debugger lines, and see how it works:

#require 'byebug'

class Array     def quicksort         #debugger         return [] if empty?         pivot = delete_at(rand(size))         left, right = partition(&pivot.method(:>))             return *left.quicksort, pivot, *right.quicksort         end end

p [34, 2, 1, 5, 3].quicksort

I’ve found that one way to really understand a concept is to have it explained to me in different ways. Then, piecing those together, I really get a firm grasp on the concept. Hopefully these examples do just that.

[davidmcafee]

-50

Short post for today: I added flash notices to some of my blog’s functions, and then added comment functionality.

[davidmcafee]

-51

Today I continued progress on the Blogger tutorial, finally worked out the bug on the “delete article” action, and created an “edit article” action.

Before I start App Academy, I’m also considering working through Gayle McDowell’s book “Cracking the Coding Interview” to help me get prepared to for interviews.

[davidmcafee]

-57

Today I started by setting up my environment to run Homebrew and a few other useful development tools. Interestingly, since my computer used to belong to my wife, Homebrew wouldn’t install because the name of the home directory didn’t match up with my name. I decided to start with a clean slate and bring the computer back to it’s factory state, which ended up being a really good exercise, as I’d never done anything like that on a Mac before.

After that I reviewed a few hash methods, and continued to learn more about classes. Once my system was finally updated, I installed Rails and began working my way through a Rails blog tutorial for a second time so that I could get a better grasp on the concepts. 

Though I want to continue with the momentum I’ve gained with Ruby, I also feel like it would be important to further my knowledge of HTML and CSS, along with Javascript and Rails, but for now, I’m sticking mainly with learning as much about Ruby as I can.

[davidmcafee]

-59

Yesterday I reviewed the function of the splat operator, and I think I getting a much better grasp on it’s multiple uses, specifically, how it can be useful with passing multiple arguments in a function call. I’d already known it’s use when defining a method (i.e. def method_name(*argument_list), that is, for accepting different numbers of parameters for the method, which in turn would be accessed like an array from the method. But the part that I found particularly interesting was how it also can do the opposite: the splat operator in the above case was creating an array, but it can also flatten an array. How is that useful? If I have an array that I want to pass to another method, I can use the splat operator in my method call and that method will not receive the array as an array, but as separate arguments.

[davidmcafee]

-61

I’ve got 61 days, 1 hour, and 21 minutes until I start my first day at App Academy! (http://bit.ly/aAcountdown)

Today I continued my review of blocks and procs, and then moved on to reviewing App Academy’s solutions to the practice problems for week one, day two of the prep work. I find I learn just as much from the solutions as I do from all the reading material. It’s similar to learning creative writing: the more you read, the more you imitate (and emulate) what someone else has written, the better your own writing gets. You learn to think in ways you wouldn’t have thought before, to say something in way you wouldn’t have thought to say it (or in this case, solve something in a way you wouldn’t have thought to solve it). It’s amazing to me just how simple a solution can be sometimes, and I’m really appreciating Ruby’s syntax more and more.

[davidmcafee]

-62

Today I was reviewing the App Academy readings on blocks and procs, and I'm feeling much more comfortable with the material going through it a second time. Check out this great tutorial if you are new to blocks and procs in ruby.

[davidmcafee]

-63

Today I continued working on my personal portfolio website. I’ve been working on it for a little over a week, so it’s still very rudimentary. Really, the only work I have to show is the page itself, but it’s a start, nonetheless! Since I’m hosting it on GitHub, it’s given me regular practice with git, which is totally new to me (and has saved my butt at least once). It’s also free to host, which is certainly a plus (great tutorial for hosting on GitHub here).

After that I continued working on my second pass through App Academy’s assigned prep work. Last night, before getting to the work itself, I had the feeling that I’d forgotten a lot of it. However, returning to the readings from Week 0, it was surprising to see how much I understand more deeply after having completed the prep work once. It’s also helpful to see how returning to the readings are shedding more light on some of the concepts I struggled with in the assignments in the later weeks.

Since I had finished reviewing the beginning of Peter Cooper’s “Beginning Ruby” last night, I skimmed over the first 10 chapters of Chris Pine’s “Learn to Program.” I decided to work through a problem that asked me to write my own sorting method using recursion, and a problem asking me to accurately shuffle an array. I was glad to see that my hours of prep for my timed challenges have continued to pay off, and I was able to find solutions for both, including an especially clean solution for the shuffle method. This also gave me an opportunity to practice debugging with Byebug. I feel like I still need significantly more practice until it feels like a tool I can actually utilize, though I did successfully debug a method that wasn’t working. If I hadn’t been in such a rush to get accepted to App Academy, I would have utilized Byebug much more during my first pass through the prep work.

I’ve also been using Cram.com to create sets of notecards that I can review. I realize that everyone says the best way to learn to code is to actually write code, but there are simply times that that’s not a possibility, and I’d like to use the downtime to review concepts (particularly things like regular expressions).

Since I didn’t spend much time looking through the solutions during my first pass through the prep-work, I’ve begun to read through them and research methods and techniques I don’t know how to use. A noteworthy example is using the following to sum an array of integers:

def sum(numbers)    numbers.inject(&:+) end

If you’re interested in learning more about the inner-workings of just how this works, check out this great answer on Stack Overflow.