Language++

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

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 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.

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.

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.

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.

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.

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

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

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

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. 

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 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