Full-Stack Fundamentals: Introduction 15 April 2014

This is the start of a series of posts that will detail the minimum knowledge I deem necessary to become a competent full-stack developer. In recent weeks, I have found myself acting as mentor to several friends and acquaintances, and it has become clear that sharing this knowledge in writing is going to be far more efficient and practical.

This is a Roadmap, Not a Recipe Book

My goal is going to be to explain all of the layers of the web development environment, the concepts at play within each layer, and how all of them interact.

I will focus primarily on JavaScript, but the majority of this series is going to applicable to all platforms. I will explain the different options for each of the layers, and how to evaluate them for your own projects. There will obviously be code involved, but it will stay as simple as the topic allows.

This series will run for as long as it needs to, and has no time limit. I am not trying to build a bootcamp for node.js developers, but rather give people the tools to understand what they will need to do to solve problems, and why they are doing it.

Since I will base this on weekly sessions with two of my students, they should be available every week or so. I’ll also be involving my friend André Ellis to do some illustration work, so they will hopefully be more visually arresting than a wall of text.

Intended Audience

This series is going to assume that you have at least some familiarity with web development, and quite likely that you are already working in the industry in some form or another.

A lot of my students (although not all) could be considered designers, and already understand HTML+CSS, but don’t really know much about javascript or how the backend works. They are often able to get by just copying and pasting code, that they might not completely understand, to achieve the desired effect.

This group includes the majority of web developers I have met throughout my career, and almost everybody that has ever built a WordPress or Drupal theme.

Self-Confidence Through Understanding

I think that the biggest problem for this group of web developers is that they lack confidence in their own capabilities. We have allowed them to put themselves in boxes that do nothing but limit what they think they should be able to do. I think the best way to help these people is to provide them with the knowledge they need to understand their environment.

capability |keɪpəˈbɪlɪti|
(often capabilities) the extent of someone's or something's ability

I wrote much the Drupal theme layer and I know that building a theme requires more than enough abstract reasoning and logic to form the basis of any further study. I can’t promise that it will be easier (at least at first), but I can promise that it will be a lot simpler in the end.

Read my post on a vocabulary to describe software complexity for the exact meanings of the terms simple, easy, complex, hard, complect and simplify as used in this context.

Some Highlights

These are some of the points I will be hitting along the way. While it looks daunting, each week might cover 2-3 of the topics.

I’m going to avoid rewriting things that exist on the internet, so I will only cover many of these topics up to a level that can place them into context with the other tools I do explain more thoroughly. I will provide links on most topics to other tutorials you can study more intently.

  • Introduction
  • Motivation for Stack choice.
  • The Server Environment.
  • Node.js, the toolset.
  • JavaScript, the language.
  • Routes, via Express.
  • REST + HTTP.
  • JavaScript, Functions/Closures.
  • Data Structures (JSON, ie: objects/hashmaps/trees).
  • OOP (very brief overview).
  • Async + Events (enough to explain db calls).
  • NoSQL Databases (CouchDB).
  • Streams (local and network).
  • Linear Data (arrays/lists)
  • Iteration + Aggregation
  • Functional Programming (underscore/lodash)
  • The Browser Environment.
  • DOM + CSS (overview. some of this is out of scope)
  • CSS Frameworks (bootstrap)
  • Angular.js (to be expanded)
  • Controllers
  • Observables
  • Binding + Scopes
  • Basic Validation (JSON Schema, imperative).
  • Custom directives
  • Complex control flow (promises etc)
  • Build tools (gulp or make)
  • Module systems (browserify)
  • Template languages (jade)
  • CSS preparsers (LESS)

This should all kick off properly in May, so I will see everybody then.