Sarmad Bokhari

Thoughts on Coding and Web Development

[sarmadbokhari]

How to pair program

Excellent article on the benefits of pair programming and guidelines on setting it up: https://medium.com/@dickeyxxx/how-to-pair-program-d6741077e513

Benefits of pairing

I feel it’s worth reiterating some of the benefits of pairing that I found:

I would leave work happy. Like any engineer, I love to talk about code. Pairing lets me discuss code while not floundering on my responsibilities.

I could work on any part of the codebase. After an engineer writes some code he naturally becomes the owner of it and nobody else ever understands it. Pairing resolves this and as a result the codebase is understood more comprehensively by all.

I got way more done. Not being able to tab over to Reddit or email is a big part of this, but it’s easy to get distracted by stuff that is work-related as well. Pairing doubles the number of people making sure you’re working on the specific task at hand. This doesn’t feel like your elementary teacher looking over your shoulder by the way, it’s a lot more natural than that.

I wrote better code. It’s like you have a human debugger looking right over your shoulder. Testing works especially well here too, while one developer is writing code, often the other is thinking about how to test against it — or the other way around for TDD.

[sarmadbokhari]

RunningBuddy - MakerSquare Final Project

Three weeks and gallons of coffee later we finally have our final project ready. Here's a quick prezi of the demo we'll be giving tonight at Demo Day followed by a description of our development process. It's called RunningBuddy and it's a Ruby on Rails web app to help you find someone to run with in your locality.

It all began with an idea to build a web app to help people run more consistently and to find other people they could run with. In my own experience in trying to exercise regularly, I've found having a gym partner to be much more motivating in not only being able to commit to running/exercising 3-4 times per week, but also pushing my gym partner (and being pushed) to workout harder while at the gym. All in all having someone to workout with really helps you to remain dedicated to living a healthier lifestyle.

Development process

We started white boarding our entity relationship diagram for the project:

Then we decided what our MVP (minimum viable product) should look like, and settled for the following features (with extra features we'd like to add after building the MVP, in parentheses), a user should be able to:

login securely or sign up to make a user profile

be able to find runs in their city and join runs

be able to post a run

be able to form and running groups (RunningCircles)

(make a monetary commitment to join a run - to hold yourself accountable. We discussed the option of having funds distributed among your group if you don't show up and bail on your commitment or have the funds donated to a health & wellness non-profit of your choice)

(geo-locate and track your run and keep stats about your runs)

Thereafter we built out our UI (user interface), again on the whiteboard, to get a view of what our web app would look like:

Only after completing this process of properly planning and whiteboarding our application did we begin the coding process. We decided to build a Ruby on Rails app with Test Driven Development (using RSpec), here's a link to our github repo with our test. Here's a diagram of our full web app structure along with the APIs we used to: login users via facebook, display maps with Mapbox, and pull in local weather with OpenWeatherAPI.

Then my coding partner and I split up and focused on meeting daily coding benchmarks, meet regularly to update each other on our progress, and work through challenges we faced along the way.

Here's a couple screenshots of our user dashboard, running posts, and running circles pages:

[sarmadbokhari]

Gotta love the internet speeds in ATX

[sarmadbokhari]

Node-Dev to Never Have to Reload the Server Again

Checkout and install node-dev (https://github.com/fgnass/node-dev) to never have to reload the server again. If any changes are saved to your server files, Node-Dev will automatically restart your server.

[sarmadbokhari]

What I've learned in the last 2 months

Vagrant

ssh

virtual box

Git

commits & conflicts

merging

branching

collaborating with a team

Ruby

classes

instance variables

class variables

attributes

inheritance

modules

mixins

gems, bundler

TDD

RSpec

stubbing methods

stubbing time

unit tests

integration tests

avoiding brittle tests

Software Design

Entities

Business Logic

Use Case

Database Implementation

Delivery Mechanisms

Database

Data models and diagrams

SQL queries and SQLite

ActiveRecord

InMemory

tables

records

polymorphic associations

join tables, has_many

belongs_to, has_many through

The Web

Server vs. Browser

Http requests

Anchor links vs forms

REST

HTML, ERB

Sinatra

Sessions

Rails

routes

resources

controllers

views

partials

layouts

auth tokens

Javascript

objects, nested objects

functions

anonymous fxs

callback fxs

event handlers

constructor functions

keyword this

closures

prototype

ajax

JS Frameworks

built my own jQuery

built my own template engine

built my own event system

models, views, presenters

[sarmadbokhari]

ActionMailer

ActionMailer and MailCatcher allows you to setup an automatic email system with your rails project.

Checkout ActionMail Rails Guide and MailCatcher

[sarmadbokhari]

Life as an aspiring web developer at MakerSquare

[sarmadbokhari]

JavaScript Test Driven Development (TDD)

TDD stands for Test Driven Development, a programming methodology that allows developers to spend less time debugging code and more time adding features.

In JavaScript, the most basic function in TDD is the assert function which defines how we expect our code to behave:

function assert(message, expr) {     if (!expr) {         throw new Error(message);     }     return true; }

So a basic test to concatenate (join) two strings would look like:

function concatTwo(x, y){     return x + y; };

function assert(mess, expr){     if (!expr){         throw new Error(mess)     }     return true; };

assert("This concacts two strings", concatTwo("hello", " world") == "hello world!")

If the function works, it should return true. Otherwise it should raise an error: "Error: This concacts two strings".

[sarmadbokhari]

MakerSquare

Learning Ruby and JavaScript web development at MakerSquare in Austin, TX

More to come!