Friday wrapped up my second week of General Assembly Boston’s Web Development Immersive program: as of this weekend, I’m one-sixth done, which is at this point mostly terrifying. How can there be only ten weeks to go?!?

I feel like I’m learning cool things (making AJAX requests that use methods other than GET, for example), but in a very, very controlled and somewhat black box-y environment. GA’s basic approach to a day of class is: pull down these git repos, run Node and/or Bundler commands, and then open up a specific file and do a specific thing. I understand why they don’t want to throw us off the deep end and go too far into things like “runtime environments” and “what is a gem” while we’re still asking questions like “what does ‘PATCH’ mean?,” but at this point I would struggle to implement what I’m learning outside of the structure of GA’s pre-packaged tooling.

To be fair, this is probably because at this point, most of us are only maybe half a step above this:

project manager: i know enough coding to be dangerous

*winks*

literally ruins entire codebase

— I Am Devloper (@iamdevloper) February 8, 2016

So. On to the cool stuff:

Day 6

More about fat arrow functions, which (along with template literals) remain one of my new favorite things about JavaScript:

• The value of this doesn’t change (and can’t be changed) within a fat arrow function. this is fixed at the value it was when the function was called. (This is also known has “having only a lexical this, not a dynamic this“).
• Fat arrow functions can’t be used as Constructors: they don’t have a prototype, and they don’t have a Construct method.
• Fat arrow functions don’t have an arguments variable.

A bunch of methods for array manipulation: .every().filter(), .forEach(), .map(), .reduce(), and .some().

Assignment using the || (OR) operator: result will be set to the first truthy value. If there are no truthy values, result will be set to the last value. Examples:

     let result = 'result' || 0;
     > 'result'
     let result = undefined || 0;
     > 0
     let result = 7 || 3;
     > 7

Apparently it’s now déclassé to set CSS styles on IDs.

A couple of cool tricks for Sublime/Atom:

• ⌘ + ? will add an empty comment (using the correct syntax for whichever language you’re using)
• ⌘ + multiple clicks will set multiple cursors within a document

Day 7

Building multi-row, multi-column CSS layouts from scratch: a serious weakness of mine. Ouch. Also, wireframes that don’t conform to a grid: BOOO.

There are THREE values for box-sizing: content-box (default), border-box (reasonable), and padding-box (only supported in FF.). More in CSS Tricks: Box-Sizing.

An explanation of those horrid unwanted spaces between inline-block elements.

Day 8

First time using Rails! Though only very, very lightly: we cloned the existing Rails code for a simple API and got it running locally so we could make curl and AJAX requests against it.

Some conventions for writing JavaScript:

• “Predicate” functions return true or false. Begin names of predicate functions with “is” (isEven, isOdd, etc.).
• Use “on” as a prefix for handlers (onGetAllBooks, onSignUp, etc.).

You can use debugger; as a standalone line in Node to set a breakpoint.

Day 9

Philip Roberts’ “What the heck is the event loop anyway?” is an excellent introduction to the JS event loop. My notes:

• one thread === one call stack === one thing at a time (single threaded)
• call stack: data structure. records place in the program. step into a function: add something to call stack. complete a function: pop it off call stack.
• slow things “block” the stack b/c JS can only do one thing at at time.
• particularly bad in JS b/c of browsers: you click on a button and get stuck, and the browser can’t return that button back to its un-depressed state. everything hangs. this is because the browser can only render when the call stack is empty.
• callbacks get pushed to a queue when they’re ready to run, NOT to the call stack.
• the event loop monitors the queue & the call stack. when the call stack is empty, it moves one thing from the queue to the call stack so it can run.
  • this is why callbacks passed to setTimeout with a timeout of 0 ms will run *after* lines of code that follow setTimeout. the event loop has to wait to give that callback to the call stack until the call stack is empty, even though the timeout is 0.
  • setTimeout is not a guaranteed time to execution. it’s a *minimum* time to execution, since we have to wait for call stack to clear before callback can run.

Day 10

We spent the last three days of this week on HTTP methods (GET/POST/PATCH/DELETE) and AJAX. We started by using curl requests to interact with a basic books API, then built AJAX requests to replicate that process in the browser (click on a button, send the request, handle success and failure). Day 10 focused on authentication: signing up/logging in/logging out, and doing things (changing information, viewing protected information) that require an auth token.

Coming up

Next week is our first “project week.” The challenge is to build a single-page tic-tac-toe game in JavaScript that relies on an existing Rails API to help with authentication and data storage. I’m looking forward to putting what we’ve learned over the last two weeks together into something usable, rather than a series of code snippets that aren’t connected. I feel like I have a good pile of building blocks now, and I’m excited to start using them to *build.*

Today is the first day of my second week in General Assembly Boston’s Web Development Immersive program, a twelve-week, full-time course focused on JavaScript and Rails. The course is intended to take people from no knowledge of programming to a full-time position as a developer, so some of the past week has been review, but I’ve loved every single second of it. Instead of my standard-ish This Week I Learned posts for the next three months, I’m hoping to do quick weekly recaps of how the program’s going.

Day 1

We spend most of Day 1 on the command line interface and on git. A couple of cool things:

• cd - takes you to your previous working directory. SO HANDY.
• use git checkout -b newbranchname to create a new branch and check out that branch simultaneously
• I fixed my first-ever merge conflict!
• GA emphasizes frequent commits and long commit messages. This wasn’t part of the course, but I recently learned about Angular.js-style commits, which seem like a great way to organize and communicate.

Day 2

Day 2 was our first day working with JavaScript. A couple of new pieces of information/new conventions:

• Using let and const instead of var to declare variables. ES6 introduced these as a way to offer block scope. Eric Elliot explains in JavaScript ES6+: var, let, or const?.
• Some JavaScript hilarity (WAT)
• Not new, but a good reminder: i++ (prefix increment) will return i, then increment. ++i will increment, then return the new value of i.
• Fat arrow functions.

Perhaps embarrassingly excited about fat arrow functions #SOCOOL #javascript #generalassembly

— RebekahHeacockJones (@rebekahredux) August 23, 2016

Day 3

• Seems obvious in hindsight, but you can isolate the unique elements in an array like this:

  let words = ['lots', 'of', 'words', 'of', 'words'];
  let uniqueWords = {};
  for (let i = 0, max = words.length; i < max; i++) {
    uniqueWords[words[i]] = true;
  } 
  

  This will give you an object where the keys are the unique elements in the array, and the values are true (as a convention; you can choose anything you want for the values). This is much simpler than my original approach, which involved…comparing all of the elements of the array to all of the elements? I don’t know. It was complicated and involved, and I don’t recommend it. Do this instead. If you want the final format to be an array, you can use Object.keys() to extract the keys (the unique words) and store them in a new array.

Day 4

• Object properties are “attributes” when they point to values/primitives. Use constructor functions to attach attributes to an object.
• Object properties are “methods” when they point to functions. Use prototypes to attach methods to an object. (Why? Functions that are attached using a constructor will be copied and attached over and over again to each new instance of an object. This is a huge waste of memory.)
• Properties that begin with underscores are private (by convention): not intended for direct access or assignment.
• “accumulator pattern” (all of the online resources I can find about this talk about it in Python, but it applies in other languages): initialize result, iterate, return result
• We started using node to run and test scripts.
• A callback is a function that is passed as a parameter to and executed inside of another function.

Day 5

• When filtering and transforming an array (arrresultsresults[i] within an if statement can result in “holes” in the array when the original arr[i] doesn’t pass the filter. It’s better to use results.push to skip values that don’t pass, resulting in a cleaner results array.
• Template literals (WHAAAAAAAAT so cool).

HOW DID I NOT KNOW ABOUT TEMPLATE LITERALS https://t.co/JHA4CXKcJv #teamnomoreplussigns #syntacticsugar #generalassembly

— RebekahHeacockJones (@rebekahredux) August 26, 2016

To sum up the week:

So deeply in my happy place right now that I can barely handle it. #generalassembly @ General… https://t.co/cGWFup2yW7

— RebekahHeacockJones (@rebekahredux) August 26, 2016