For the past three weeks, I’ve been going through Thinkful’s Front End Course. A major reason that I chose this course was information I heard from an episode of the Ruby on Rails podcast where their CEO talked about programming schools in general and their program specifically. I liked the fact that they made their program more accessible to people and that they place an emphasis on students pacing themselves instead of requiring the maximum time possible. Even though the payments are still relatively expensive compared to other online courses, the fact that it doesn’t require a long term commitment was a huge plus. That and the chance to talk to a professional web developer about my code was what sealed it for me.

For a long time, I knew the basics of CSS and front end development when I read it, but I wasn’t able to use it off the top of my head. I liken it to being able to answer a multiple choice question but failing on the free response ones. Most of what I did before this course was limited to using bootstrap, adding markup to html to correspond with the grids and using their stylings for common components like navigation and form fields.

A lot of the starting material was stuff that I’ve seen before but using it in practice without a step by step guide made a huge difference. This was also a time when another person was actually critiquing my programs and giving me constructive feedback on how to make it better. That feedback alone encouraged me to work at least twice as hard as I would have otherwise because I had someone else to keep me accountable.

I was able to make a static portfolio site that I’m planning to migrate to its own domain in the future along with multiple projects to showcase with it. I’ve already included two demo Rails app I made and I’m planning to add more once I deploy them to heroku. All of this is still a work in progress but it’s really invigorating to see my work displayed like that. I’m looking forward writing a blog post on each project I made in the course and also using the things I learned to edit the css for this blog.

My first try on an elevator pitch about myself:

On the server side, I enjoy working with Ruby on Rails. I write tests using rspec but I don’t follow a strict Test Driven Development workflow. The best advise I was given is that I should never let my own inexperience stop me from writing code and exploring what happens when I run it. Tests are great to give myself immediate feedback on what I’m programming but there’s nothing wrong with admitting that I don’t know enough to ensure that my tests are actually useful or that it’s hindering me from learning at some points. I use Bootstrap or Foundation to start positioning sections of html along grids and styling common elements like navigitaion bars and form inputs but I know how to work with css without relying on them. I use jquery to include behavior in the client side and I have enough exposure with the ember that I’m very excited to learn more about what I can build with it.

Links of resources that I’ve been reading

• Making an elevator pitch along with examples
• Recruiter/ Developer Presentation
• Importance of things outside the resume
• Skillcrush video on how to write a resume
• Rails specific tips
• General tips on the education section

General notes from those links

Elevator Pitch

• Don’t sound one dimentional and include your personal passions.
• Say as little as possible.
• Decide what kind of work you’re looking for.
• Figure out who you’re talking to.
• Ask yourself what problem you solve rather than what you do.
• Describe what you do in one day.
• Include numbers and concrete detail.
• Be quirky or unexpected.
• Take something out.
• Turn it into a conversation.

Six steps towards a resume

• Identify the job requirements
• Pick a Resume Type
• Create a tailored summary
• List of previous experiences
• Include relevant skills
• Review Format and Feel

Things to consider

• A screener’s job is to quickly screen out the worst resumes.
• Don’t use more than one font.
• Check for spelling and grammar mistakes.
• Double checke the dates.
• Delineate sections.
• Don’t include an overview section since a cover letter is better for it.
• Include keywords carefully.
• The tech and hr review is further screened by quick decisions and more detailed reading. Ensure you pass those quick ones since they’re deal breakers
• The three major resume adaptions are tech, hr and a mix of both, figure out which once a job post is leaning towards.

The Three people who read the cover letter

• HR Person / Recruiter - Appropriate skills, Employable, and Eligible
• Hiring Manager - Do you have actual experience, Do you have the other required skills, Do you have any open source work
• The Interviewing Developers - Do you know programming, Could they work with you, Give them interesting things to talk about you

Summary Section

• Help tell them that you’re in the right place.
• Demonstrate understanding by being descriptive about your toolset.
• Give interesting topics that other programmers could talk to you about - personal development projects.

Skills

• Talk about important things first.
• Talk about experiences as proof that you’ve actually used the tools you talk about.
• Insights gained from experience and something you could talk about in an interview.
• Talk about something slightly contentious and this gives an interviewer something to ask and something you can prepare for.
• ‘some exposure’ is a great phrase to point to something you’ve played with before but aren’t prepared to answer in detail.
• Certain skills in bold for recruiters.
• User the same approach for non language specific skills.
• Demonstrate understanding by giving opinions.
• Throw in a little bit of personality but don’t go overboard.
• Throw in other things that aren’t too important at the end.

Open Source Experience

• Make it prominent if you have a lot of it.
• Link to your blog if you have great content and only mention it if you don’t.
• If you don’t have a lot of it, talk about things you’ve done outside of work or what you’ve learned like online courses.

Other stuff

• Unless you have something awesome to share, leave out Education
• If you did not finish your degree, then write in the amount of credits that you obtained, what major you pursued, and relevant coursework taken.

Outside the resume

• Have an online footprint
• Links to portfolio, projects, and GitHub then review them
• Prioritize work that’s relevant to the position
• A bulleted list of links in your cover email
• Employers will google you

Commands I’ve learned

• git commit --amend
• git log --pretty=oneline shows a terse history mapping containing the commit id and the summary
• git rebase --interactive provides the summary for each commit in the editor it invokes
• git config --global alias.home 'rev-parse --show-toplevel' - cd 'git home'

I’m currently trying to use more of snippets in vim and this is a group of commands that I think would help me out. These snippets are provided by two different repositories and I installed vim-pathogern to add more of my own in the future.

honza vim-snippets

Rails

• snippet resources - Create resources controller class
• snippet befc - before create
• snippet befd - before destroy
• snippet befu - before update
• snippet befv - before validation
• snippet defcreate - def create - resource
• snippet fina - find(:all)
• snippet defi - def initialize
• snippet class - class def initialize … end end

Markdown

• snippet link - Link to something
• snippet img - Image
• snippet ilc - Inline Code
• snippet cbl - Codeblock

Html

• snippet body - body tags
• snippet div - div tags
• snippet div. - div tags with class
• snippet div# - div tags with class and id
• snippet p - paragraph tags
• snippet ul - unordered list tags
• snippet li - list item tags

r00k dotfiles

Ruby

• snippet =b - comment code block
• snippet req - reuire statement
• snippet case - case when statements
• snippet def - def method with end
• snippet if - if statement
• snippet ife - if else statement
• snippet elsif - elsif statement
• snippet Enum - include Enumerable and create each method
• snippet Comp - include Comparable and create spaceship method
• snippet defs - def self. statement
• snippet ea - each method
• snippet eai - each with index method
• snippet inj - inject method
• snippet map - map method

ERB

• snippet p
• snippet pe
• snippet end

Rspec

• snippet new - test double with allow
• snippet desc - describe block
• snippet it - it block
• snippet con - context block
• snippet bed - before block
• snippet hc - expect page have content
• snippet let - let block
• snippet ex - expect to
• snippet scen - scenario block
• snippet rrh - require rails helper

Commands I’ve learned

• rails new api -T -d postgresql - The -T is the same as –skip-test-unit
• rails new bostonember -B -S - Skips bundle install and sprockets
• FactoryGirl.create_list(:contact, 10)
• rails g model Account name:string subdomain:string --skip

Lately, I’ve been envious of graphic text editors and the way they navigate through project files. I’ve been doing a lot of tutorial projects in Ruby and Javascript along with cloning documentation from github as a reference offline. I downloaded atom to accomplish this but I’m sacrificing the speed of working with a vim/tmux setup. After watching Upcase’s latest Weekly Iteration on Vim, I decided to try achieving a deeper understanding of Vim’s capabilities.

Rails Vim commands

• :PluginInstall - Install Vundle plugins

• gf - Go to File

• CTRL + o - Go back to the previous file

• CTRL + i - Go forward in visited files

• :jumps - List visited files

• RcontrollerJump - to relevant controller, as if you are in a model file, and you want to jump to its controller.

• RmodelJump - to the model

• RviewJust - add the name of the view like (index, show, edit) to jump to the relevant view.

• RunittestJump - to the relevant unit test.

• RfunctionaltestJump - to the relevant test.

• RintegrationtestJump - to the integration test, integration spec, or cucumber feature specified.

• RspecJump - to the given spec.

• RmigrationUse - tab completion to choose from the available migrations and jump to one of them.

• RschemaJump - to the project schema.

• RmailerJump - to the given mailer.

• RhelperJump - to the given helper.

• RjavascriptJump - to given JavaScript or CoffeScript file.

• RstylesheetJump - to given stylesheet.

• RtaskJump - to given task.

• RlibJump - to given lib, if no arguments specified it jumps to the Gemfile.

• RlayoutJump - to the layout of the current controller.

• :RV - Open files in vertical split windows

• :RS - Open files in horizontal splits

• :RT - Open files in new tabs

• :RD - Open files in current buffer

• :Rgenerate migration add_something_to_tablename

• :Rserver, :Rserver! and :Rserver!- - Running, Restarting, and Killing the Serve

• :Rpreview - Open the correct URL for the current file

Vim-rspec

• map <Leader>t :call RunCurrentSpecFile()<CR>

• map <Leader>s :call RunNearestSpec()<CR>

• map <Leader>l :call RunLastSpec()<CR>

• map <Leader>a :call RunAllSpecs()<CR>

Vim plugins to checkout

• vim-snipmate - Creates code templates

• ag.vim - Searching similar to grep and ack

• tcomment_vim - A plugin to comment out blocks of code

• vim-ruby-refactoring - Shortcuts for common ruby refactoring techniques

• vim-bundler - Ability to run bundler from vim

Commands I’ve learned

• gem pristine --all --only-executables

• rails _4.1.0_ new respond_to_4.

• gem install rails -v "~>4.0.0"

• rake paperclip:refresh:missing_styles

For the past two weeks, I’ve been going through as many Ruby tutorial projects as I could. Many of them were easy to follow but this time around, I’ve been trying my best to practice test-driven development as I go through the exercises. The contact manager tutorial by Jumpstart Lab was a great starting point for this because they follow this workflow.

I’ve been trying out different tools including rspec-rails, shoulda-matchers, factory_girl_rails, fabrication, minitest, and fixtures. So far, I’ve been using rspec more because of how it integrates with rails generators like scaffolding. Scaffolding generates the usual CRUD actions and rspec generates the associated test in the controller specs. I felt like I was cheating a little bit by using generators so much but the speed I was working through tutorials that used to take me multiple days was difficult to overlook. I found myself setting model fields and associations through the command line instead of migrations. Rspec’s syntax feels very natural and as familiar now as minitest’s assertions. At this point, I can appreciate what the generators do and I don’t have to build up Rails controller from the bottom up as long as I understand what is going on which each action and I’m testing throughout the whole process.

Commands I’ve learned

• rails g model sports_category --parent category

• rails g scaffold Comment content:text user:belongs_to post:belongs_to

• heroku git:clone -a myapp

• rails g scaffold Foo foo_string:string foo_text:text foo_integer:integer foo_float:float foo_decimal:decimal foo_timestamp:timestamp foo_time:time foo_date:date foo_binary:binary foo_boolean:boolean

Since I’ve been learning on my own, I’ve found that there are many resources online to help me chart a syllabus and figure out what skills I would specifically need. These are some of the links I bookmarked to figure out what I have to start learning next or what I need to work on more.

Odin Project

This was one of the first free resources I found online about web development. The format for this was similar to Treehouse’s tracks except that this one is written instead of as video tutorials.

Thoughtbot Guides

This covered a lot of detail about the tools thoughtbot uses. I’m not familiar with all of them but I found that the ones I do know are covered very well here. It’s not an introduction to them but, if you just started working with it, the guides offer general guidelines to follow until their purposes are better understood.

Sitepoint Ruby

Sitepoint has a lot of introductory material or tutorials on how to use libraries or frameworks. There’s a great variety in what they’ve written about and they publish frequently enough that there are a lot of material to go through that is very up to date.

Jumpstart Lab Tutorials

This site has a lot of projects a person could go through and create. I found their github repository a while back and saw a lot of sample apps that could be used to learn about a specific functionality.

Turing Standards

This site has a lot of questions a Ruby on Rails developer could be reasonable asked. I go through them because I feel like they’re a very good example of interview questions.

Practicing Ruby

These articles are very in-depth and valuable to learning more than just the basics of different Ruby categories. In particular, my favorite was the article about building the Enumerable module from scratch. I consider that module as one of the most important in Ruby’s standard library since it’s used a lot by Ruby programmers.

Rails Diff

Since a lot of Rails tutorials can include previous versions of Rails, I use this a lot to make sure the ones I’m following could be easily migrated to a more current version.

Ruby Regex

This is an interactive app to check Ruby regular expressions and their results. I use this a lot to make sure the regular expressions I’m using are correct. When I first started learning about regex, I used this website to practice different characters and shortcuts.

Awesome Ruby

This is a collection of libraries and tools that are written in Ruby. Looking at all of this was overwhelming at first but it’s a really great way to see what’s out there and what you could use. The first thing I looked at from here was the coding style guides which include resources for Ruby, Rails, and Rspec.

Big O

This was a good introduction on data structures and algorithms in Computer Science. I don’t use the specific things in here very much but having a working understanding of these concepts are helpful to decide which methods to use. Also, I’ve been told this is a common interview question that could stump entry level programmers especially self taught ones.

Commands I’ve learned

• find / -type d -name 'folder_name'