Index

90-9-1 rule: How to Talk People Into Things

accessibility: Software Design

accessibility - WebAIM WAVE: Software Design

active bystander: Fair Play

active listening: Managing Conflict

actual result (in unit test): Testing

ADHD: The Important Stuff

agile development: Process

agile development - conditions for success: Process

all-nighters: The Important Stuff

allocating work - chaotic decomposition: Teams

allocating work - confirmation loop: Teams

allocating work - effect of social status: Teams

allocating work - feature decomposition: Teams

allocating work - functional decomposition: Teams

allocating work - in teams: Teams

allocating work - modular decomposition: Teams

allocating work - rotating decomposition: Teams

Alloy: Tooling

ally: Starting, Fair Play

already invented here syndrome: Software Design

analysis & estimation: Process

analysis paralysis: Software Design, Process

Ant: Automation

Apache Software Foundation: The Important Stuff

APT: Tooling

assertion: Error Handling, Debugging

authentication: Security

authentication - two-factor: Security

auto-completion: Tooling

automated program repair: Debugging

automation: Automation

automation - as programming: Automation

Automattic - hiring process: Fair Play

Baldwin, James: Fair Play

Baxter, T. Carter: Fair Play

bias: Fair Play

big bang integration: Teams

Bitbucket: Using Git On Your Own

Black: Automation

Blackbox project: Process

blog - as team journal: Communicating

blog - automatically generated: Communicating

Boehm Curve: Process

Borland: Tooling

branch (in Git): Using Git On Your Own

breakpoint: Debugging

breaks (importance of regular): The Important Stuff

Brook's Law: Research

Brown, Neil: Process

browser automation - for testing: Testing

browser automation - record and playback: Testing

BSD License: Intellectual Property

bug tracker: Communicating

build manager: Automation

build manager - and version control: Automation

build manager - Ant: Automation

build manager - Make: Automation

build manager - Rake: Automation

build manager - rules for using: Automation

build manager - Snakemake: Automation

build number: Wrapping Up

Burns, Heather: Security

C: Tooling, Research

C++: Tooling

Carnac: Tooling

casual threat: Security

catch exception: Error Handling

CC-BY license: Intellectual Property

CC0 license: Intellectual Property

chaotic decomposition: Teams

checklists - benefits of: Teams

checklists - use in code review: Using Git Together

Checkstyle: Automation

chorus of explanation: Communicating

chunking: Thinking and Learning

co-op: Starting

code browser: Tooling

code clones: Research

code comprehension: Software Design

code coverage: Testing

code metrics - ineffectiveness of: Research

Code of Conduct: Starting, How to Welcome Newcomers, Contributing

Code of Conduct - responding to violations: Fair Play

code review: Process

code review - effectiveness of: Using Git Together

code review - for security: Security

code review - procedure: Using Git Together

code review - responding to: Using Git Together

cognitive bias: Research

cognitive dimensions framework: Research

cognitive load: The Important Stuff

cognitive load - extraneous: Thinking and Learning

cognitive load - germane: Thinking and Learning

cognitive load - impact of checklists: Teams

cognitive load - in debugging: Debugging

cognitive load - intrinsic: Thinking and Learning

cognitive load theory: Thinking and Learning

cognitive transition: Thinking and Learning

collective action: Fair Play

comments - as communication: Communicating

commit (version control): Using Git On Your Own

commit message (version control): Using Git On Your Own

common programming errors: Debugging

commons: Fair Play

communication - asynchronous: Communicating

communication - blog: Communicating

communication - comments: Communicating

communication - email: Communicating

communication - instant messaging: Communicating

communication - synchronous: Communicating

communication - wiki: Communicating

community of practice: How to Welcome Newcomers

competent practitioner: Thinking and Learning

competent practitioner - documentation needs: Communicating

Comprehensive TeX Archive Network (CTAN): Tooling

conceptual architecture - diagram: Software Design

concrete examples: Thinking and Learning

concurrent systems - difficult of debugging: Debugging

CONDUCT file: Starting, Intellectual Property

configuration - layered: Software Design

configuration - parameters: Research

confirmation loop - allocating work: Teams

conflict (in Git): Using Git On Your Own

conflict (in Git) - repeating: Using Git Together

conflict (interpersonal): Managing Conflict

conflict (interpersonal) - escalating: Managing Conflict

conflict (interpersonal) - handling: Managing Conflict

confounding variable: Research Methods

console: Tooling

continuous integration: Automation, Process

continuous integration - GitHub Actions: Automation

continuous integration - Travis CI: Automation

contrarian (why not to be): Teams

CONTRIBUTING file: The Important Stuff, Starting

control group: Research Methods

controlled experiments: Research Methods

Conway's Law: Teams

copyright: Intellectual Property

coverage - code: Testing

coverage - path: Testing

Creative Commons: Intellectual Property

Creative Commons - CC-BY license: Intellectual Property

Creative Commons - CC0 license: Intellectual Property

Creative Commons - no commercial use: Intellectual Property

Creative Commons - no derivative works: Intellectual Property

Creative Commons - share-alike: Intellectual Property

crunch mode: The Important Stuff

CSS selector - use in testing: Testing

cultural fit (as unconscious bias): Fair Play

cutting corners: Process

CVS (version control): Using Git On Your Own

dark matter developer: Research Methods

data mining: Research Methods

data structure diagrams: Software Design

dead code: Research

debugger - breakpoint: Debugging

debugger - single-stepping: Debugging

debugging - concurrent systems: Debugging

debugging - importance of good habits: Debugging

debugging - rubber duck: How to Make Yourself Comfortable

debugging - symbolic debugger: Debugging

debugging - why schools don't teach: Debugging

defensive programming: Error Handling, Debugging

delta debugging: Debugging

demotivation: Thinking and Learning

design by contract: Software Design

design for test: Testing

design pattern - model-view-controller: Testing

development process: Process

DevOps: Automation

diagnostic power (of formative assessment): Thinking and Learning

diagrams - conceptual architecture: Software Design

diagrams - data structure: Software Design

diagrams - entity-relationship: Software Design

diagrams - physical architecture: Software Design

diagrams - use-case map: Software Design

diagrams - workflow: Software Design

dictionary attack: Security

digital signature - for activity logs: Security

discoverability - of issues: Communicating

discovery-based learning: Thinking and Learning

discrimination: Fair Play

do-ocracy: The Important Stuff

Docker: Tooling

documentation - as communication: Communicating

documentation - embedded: Communicating

documentation - for competent practitioners: Communicating

documentation - for experts: Communicating

documentation - for novices: Communicating

documentation - what to include: Communicating

documentation generator: Tooling

documentation generator - JSDoc: Tooling

doi2bib: Introduction

Don't Repeat Yourself: Software Design

double blind experiments: Research Methods

dual coding: Thinking and Learning

dumpster diving: Security

Dunning-Kruger effect: Teams

dynamic analysis: Tooling

dynamic analysis - Valgrind: Tooling

dynamic typing: Tooling, Research

easy mode (as a metaphor for privilege): Fair Play

editor - Emacs: Tooling

editor - Notepad: Tooling

effort-importance grid: Process

effort-importance grid - helping triage: Process

Eiffel: Software Design

elaboration: Thinking and Learning

Elbakyan, Alexander: Introduction

elevator pitch: Starting, Software Design

Emacs: Tooling

email (for team communication): Communicating

email - filters: Communicating

embedded database - use in testing: Testing

engineering tradition in computing: Research Methods

entity-relationship diagram: Software Design

error - common: Debugging

error - external: Error Handling

error - internal: Error Handling

error - misperception of frequency: Debugging

error - root cause analysis: Research

error message - internationalizing: Error Handling

error message - writing helpful: Error Handling

ESLint: Automation

Evans, Julia: Communicating, Fair Play

Excel: Research Methods

exception: Error Handling

exception - handling: Error Handling

exception - raise: Error Handling

exception - under-used and abused: Research

exception - when to check: Error Handling

exfiltrate: Security

expected result (in unit test): Testing

experimenter bias: Research Methods

expert: Software Design, Thinking and Learning

expert - code comprehension: Software Design

expert - documentation needs: Communicating

expert blind spot: Thinking and Learning

external error: Error Handling

extraneous load: Thinking and Learning

extrinsic motivation: Thinking and Learning

failure: Debugging

fairness: Fair Play

FAQ: Communicating

fault: Debugging

feature boxing: Process

feature creep (danger of): Teams

feature decomposition: Teams

feedback loops: Process

final report: Wrapping Up

finite state machines - use in software design: Software Design

fixture (in unit test): Testing

floating-point arithmetic - difficulty of testing: Testing

Flon's Axiom: Research Methods

flow: The Important Stuff, Testing, Wrapping Up

flow graph - abstract interpretation: Research

flow graph - actual: Research

flowchart: Software Design

Ford, Henry: The Important Stuff

formative assessment: Thinking and Learning

functional decomposition: Teams

fuzz testing: Testing, Debugging

garbage collection - generational: Tooling

Gender Decoder: Fair Play

GenderMag: Fair Play

General Data Protection Regulation (GDPR): Security

generational garbage collection: Tooling

germane load: Thinking and Learning

Gilliam, Terry: How to be a Good Research Partner

Git: Using Git On Your Own

Git - basic commands: Using Git On Your Own

Git - branch: Using Git On Your Own

Git - branch names: Using Git On Your Own

Git - cloning project: Using Git On Your Own

Git - commit: Using Git On Your Own

Git - commit ID: Using Git On Your Own

Git - commit message: Using Git On Your Own, Using Git Together

Git - configuring: Using Git On Your Own

Git - conflict: Using Git On Your Own

Git - creating project: Using Git On Your Own

Git - difference between add and commit: Using Git On Your Own

Git - graphical interface: Using Git On Your Own

Git - HEAD: Using Git On Your Own

Git - history: Using Git On Your Own

Git - ignoring files: Using Git On Your Own

Git - interface (indistinguishable from hoax): Using Git On Your Own, Using Git Together

Git - merge: Using Git On Your Own

Git - post-commit hook: Automation

Git - pre-commit hook: Automation

Git - pull request: Using Git Together

Git - pull request - comments: Using Git Together

Git - reasons for popularity: Using Git On Your Own

Git - rebase: Using Git On Your Own

Git - recovering old files: Using Git On Your Own

Git - remote: Using Git On Your Own

Git - saving changes remotely: Using Git On Your Own

Git - showing status: Using Git On Your Own

Git - viewing differences: Using Git On Your Own

Git - workflow: Using Git On Your Own

GitHub Actions: Automation

GitHub Pages: Communicating

GitLab: Using Git On Your Own

GNU Public License (GPL): Intellectual Property

Goal-Question-Metric: Research

Goodhart's Law: Debugging, Research

Google - unfair hiring practices: Fair Play

Google Summer of Code: Introduction

governance: The Important Stuff, How to Welcome Newcomers

Graf, David: Introduction

Grand Perspective: Tooling

GUI designer: Tooling

harassment: Conclusion

Hippocratic License: Intellectual Property

hiring process: Fair Play

hiring process - Automattic: Fair Play

hiring process - healthy: Fair Play

hiring process - mistakes: Fair Play

history of computing: Teams

hitchhiker: Teams, Managing Conflict

Homebrew: Tooling

Hoye, Mike: Fair Play

human rights: Intellectual Property

humanist tradition in computing: Research Methods

hypercorrection effect: Thinking and Learning

IDE: Using Git On Your Own, Tooling

IDE - console: Tooling

IDE - in browser: Tooling

IDE - under-used and abused: Research

IDE - VS Code: Tooling

implicit bias: Fair Play

in-memory database - use in testing: Testing

inequality: Conclusion

insider threat: Security

instant messaging - inevitable use of: Communicating

institutional priorities: Fair Play

intellectual property: Intellectual Property

intellectual property - copyright: Intellectual Property

intellectual property - patent: Intellectual Property

intellectual property - trade secret: Intellectual Property

intellectual property - trademark: Intellectual Property

interleaving: Thinking and Learning

internal error: Error Handling

internship: Starting

interruption bingo (in meetings): The Important Stuff

interruptions: The Important Stuff

intimate threat: Security

intrinsic load: Thinking and Learning

intrinsic motivation: Thinking and Learning

introspection: Thinking and Learning

issue: Communicating

issue - classifying: Communicating

issue - description of: Communicating

issue - fields: Communicating

issue - good titles: Communicating

issue - timestamps: Communicating

issue tracker: Communicating

issue tracker - as course deliverable: Wrapping Up

issue tracker - helping triage: Communicating, Process

issue tracker - Jira: Communicating

issue tracker - milestones: Communicating

issue-tracking system: The Important Stuff

Java: Tooling, Research

Java - build manager: Automation

Java - style checker: Automation

JavaScript: Tooling

JavaScript - style checker: Automation

Jekyll: Communicating

Jira (issue tracker): Communicating

JSDoc: Tooling

just-in-time compiler: Tooling

Kaplan-Moss, Jacob: Communicating

Kendzior, Sarah: How to Change the World

LaTeX: Wrapping Up

learned helplessness: Thinking and Learning

learner persona: Introduction, Thinking and Learning

learning strategies: Thinking and Learning

learning strategies - concrete examples: Thinking and Learning

learning strategies - dual coding: Thinking and Learning

learning strategies - elaboration: Thinking and Learning

learning strategies - interleaving: Thinking and Learning

learning strategies - retrieval practice: Thinking and Learning

learning strategies - spaced practice: Thinking and Learning

learning styles: Thinking and Learning

legitimate peripheral participation: How to Welcome Newcomers

Lehrer, Tom: Research Methods

lending privilege: Fair Play

LibreOffice: Wrapping Up

license - software: Intellectual Property

license - why not to write your own: Intellectual Property

LICENSE file: Starting, Intellectual Property

linter: Automation

Linux: Tooling

Linux - toxic leadership: Tooling

logging: Error Handling

logging - during debugging: Debugging

logging - for security: Security, Error Handling

logging - levels: Error Handling

logging - output format: Error Handling

logging - rotating files: Error Handling

long-term memory: Thinking and Learning

Lua: Software Design

MacOS: Tooling

macro: Security

major version number: Wrapping Up

Make: Automation

Make - pattern rule: Automation

Make - shortcomings: Automation

Markdown: Communicating

Markdown - for final report: Wrapping Up

marketing: Wrapping Up

Martha's Rules: The Important Stuff

mathematical tradition in computing: Research Methods

MathML: Wrapping Up

MATLAB: Research Methods

meetings: The Important Stuff

meetings (online): The Important Stuff

meetings - discussion: The Important Stuff

meetings - decision: The Important Stuff

meetings - extra rules for post mortems: Wrapping Up

meetings - interruption bingo: The Important Stuff

meetings - three sticky notes: The Important Stuff

Mencken, H.L.: How to be a Good Research Partner

mental health: Teams

mental health (stigma associated with): The Important Stuff

mental model: Communicating, Thinking and Learning

mental model - Git: Using Git On Your Own

mentoring: Thinking and Learning

Mercurial (version control): Using Git On Your Own

merge (in Git): Using Git On Your Own

microphone: How to Make Yourself Comfortable

microservice: Software Design

Microsoft Project: Tooling

Microsoft Visual Studio Code: Tooling

Microsoft Word: Wrapping Up

milestone (in issue tracker): Communicating

minor version number: Wrapping Up

minutes (of meetings): The Important Stuff

MIT License: Intellectual Property

mock object: Testing, Debugging

model - of software development: Software Design

model-view-controller architecture: Testing

model-view-controller architecture - testing: Testing

modeling tools - Alloy: Tooling

modeling tools - TLA+: Tooling

modular decomposition: Teams

motivation - extrinsic: Thinking and Learning

motivation - intrinsic: Thinking and Learning

motivation - self-efficacy: Thinking and Learning

multitasking: The Important Stuff

Myers-Briggs Type Indicator: Research, Thinking and Learning

negative results (failure to publish): Research Methods

neurodivergent: The Important Stuff

neurotypical: The Important Stuff, Thinking and Learning

Node.js - package.json file: Automation, Tooling

non-disclosure agreement: Intellectual Property

non-disclosure agreement - abuse of: Security

not invented here syndrome: Software Design

note-taking (as a learning strategy): Thinking and Learning

Notepad: Tooling

novice: Software Design, Thinking and Learning

novice - code comprehension: Software Design

novice - documentation needs: Communicating

NPM: Tooling

NPMS: Tooling

onboarding checklist: Onboarding Checklist

open offices (evils of): The Important Stuff

Open Source Initiative: Intellectual Property

Open-Closed Principle: Software Design

org chart - importance of: Fair Play

overwork: The Important Stuff

package - as course deliverable: Wrapping Up

package - building: Software Design

package manager: Tooling

package manager - APT: Tooling

package manager - Homebrew: Tooling

package manager - NPM: Tooling

package manager - package ratings: Tooling

package manager - pip: Tooling

package manifest: Automation

packaging: Software Design

pair programming: Process

pair programming - effect of personality: Research

paradox of tolerance: Fair Play

patch (software): Wrapping Up

patent: Intellectual Property

path coverage: Testing

peer evaluation: Teams

PEP8: Research

performance review - importance of written criteria for: Fair Play

performance testing - manual: Testing

Perl: Tooling, Research

persuasion: How to Talk People Into Things

Petre, Marian: Introduction

Petrov, Andrey: How to Hand Over and Move On

phishing: Security

physical architecture - diagram: Software Design

pip: Tooling

placebo: Research Methods

PLOS: Introduction

plugin - for IDE: Tooling

post mortem: Wrapping Up

post-commit hook: Automation

post-condition: Software Design

post-condition - strengthening: Software Design

Pratchett, Terry: Error Handling

pre-commit hook: Automation

pre-condition: Software Design

pre-condition - weakening: Software Design

pre-registration of experiments: Research Methods

process - waterfall: Process

Proctorio (invasive surveillance): Fair Play

product manager: Process

productivity: The Important Stuff

productivity - comparative: Research

productivity - SPACE framework: Research

profiler: Testing

programmers - happiness: Research

programming - innate ability: Research

programming in the large: Software Design

programming language - compiled: Tooling

programming language - dynamically typed: Tooling

programming language - ease of learning: Tooling

programming language - interpreted: Tooling

programming language - statically typed: Tooling

project course - characteristics of: Starting

project manager: Process

project organization - standard files: Starting

pseudoscience - learning styles: Thinking and Learning

pseudoscience - Myers-Briggs Type Indicator: Research

pull request: Using Git Together

pull request - serial number: Using Git Together

Python: Tooling, Research, Research Methods

Python - PEP8 style guide: Research

Python - style checker: Automation

qualitative methods: Research Methods

quasi-experiment: Research Methods

Quorum: Tooling

R (programming language): Research Methods

radical candor (as bullshit): Fair Play

radicalization: Conclusion

raise exception: Error Handling

Rake: Automation

reading code: Debugging, Research

reading code - effect of variable names: Research

reading code - eye tracking studies: Research

reading code - fMRI studies: Research

README file: The Important Stuff, Starting

rebasing (in version control): Using Git On Your Own

refactoring: Tooling

refactoring - for code review: Using Git Together

remote (in Git): Using Git On Your Own

reporting - to your manager: Communicating

repository (version control): Using Git On Your Own

Representational State Transfer: Software Design

reproducible example (reprex): Communicating, Debugging

requirements error: Debugging

REST: Software Design

retrieval practice: Thinking and Learning

Robinson, Evan: The Important Stuff

rotating decomposition: Teams

rubber duck debugging: How to Make Yourself Comfortable

Ruby: Tooling, Research

sanitizing data: Security

Scalzi, John: Fair Play

Schneier, Bruce: Security

Sci-Hub: Introduction

scientific tradition in computing: Research Methods

Scottish verdict: Research

Scratch: Thinking and Learning

scriptability: Software Design

Scrum: Process

secure deletion tool: Security

security theater: Security

self-confidence (lack of): Teams

self-efficacy: Thinking and Learning

semantic versioning: Wrapping Up

sense vote: The Important Stuff

Shopify - support for alt-right sites: Fair Play

short-term memory: Thinking and Learning

short-term memory - chunking: Thinking and Learning

short-term memory - limited capacity of: Thinking and Learning

significance hacking: Research Methods

single-stepping: Debugging

Snakemake: Automation

Snowden, Edward: Security

social engineering: Security

sociotechnical congruence: Teams

software design - accessibility: Software Design

software design - evolution: Software Design

software design - influence of testability: Testing

software design - role of diagrams: Software Design

software design - scriptability: Software Design

software license: Intellectual Property

software license - BSD License: Intellectual Property

software license - GNU Public License (GPL): Intellectual Property

software license - Hippocratic License: Intellectual Property

software license - MIT License: Intellectual Property

software license - open: Intellectual Property

software license - why to use the MIT License: Intellectual Property

software patch: Wrapping Up

software portal - Bitbucket: Using Git On Your Own

software portal - communication tools: Communicating

software portal - GitHub: Using Git On Your Own

software portal - GitLab: Using Git On Your Own

SPACE framework: Research

spaced practice: Thinking and Learning

spearphishing: Security

sprint: Process

SQL injection attack: Security

Stack Overflow: Communicating

stand-up meeting: Process

standard project files: Starting

static analysis: Automation

static site generator: Communicating, Wrapping Up

static site generator - Jekyll: Communicating

static typing: Tooling, Research

string I/O: Testing

style checker: Automation

style checker - Black: Automation

style checker - Checkstyle: Automation

style checker - ESLint: Automation

Subversion (version control): Using Git On Your Own

surveillance: Conclusion

symbolic debugger: Debugging

Taylor & Francis: Introduction

team contract: Teams

teams - allocating work: Teams

teams - benefits of diverse ability levels: Teams

teams - dissolving: Managing Conflict

teams - effect of having friends on: Teams

teams - effective size of: Teams

teams - isolating at-risk students: Teams

teams - learning benefits of: Teams

teams - selecting: Teams

teams - taking schedules into account: Teams

Tech Solidarity: Security

technical debt: Communicating, Automation

term: Contributing

test framework: Testing

test runner: Testing, Tooling

test suite: Testing

test-driven development: Process

testability - influence on software design: Testing

threat - casual: Security

threat - insider: Security

threat - intimate: Security

three sticky notes (in meetings): The Important Stuff

throw low, catch high: Error Handling

ticketing system: Communicating

time boxing: Process

time management: The Important Stuff

timestamp - of Git commit: Using Git On Your Own

TLA+: Tooling

to-do list: The Important Stuff

tone policing: The Important Stuff, Teams

toxic people - misperception of: Managing Conflict

toxic people - rarity of: Managing Conflict

trade secret: Intellectual Property

trademark: Intellectual Property

Travis CI: Automation

treatment group: Research Methods

triage: Process

triage - using issue tracker: Communicating, Process

Turbo Pascal: Tooling

two-factor authentication: Security

type declaration - effect on readability: Research

type declaration - effectiveness at catching bugs: Research

type declaration - use in software design: Software Design

TypeScript: Tooling

typing - dynamic: Tooling, Research

typing - static: Tooling, Research

Uber: Fair Play

UCOSP: Introduction

unconscious bias: Fair Play

Unified Modeling Language: Software Design

unit test: Testing

unit test - actual result: Testing

unit test - browser automation: Testing

unit test - code coverage: Testing

unit test - expected result: Testing

unit test - fixture: Testing

unit test - floating-point arithmetic: Testing

unit test - fuzzing: Testing

unit test - influence on software design: Testing

unit test - path coverage: Testing

unit test - performance: Testing

unit test - profiling: Testing

unit test - test framework: Testing

unit test - test suite: Testing

unit test - visualization: Testing

Universal Declaration of Human Rights: Intellectual Property

University of Toronto: Introduction

Up & Go: Fair Play

use-case map: Software Design, Wrapping Up

user story - use in software design: Software Design

Valgrind: Tooling

variable naming: Research

version control: The Important Stuff

version control - and build manager: Automation

version control - centralized: Using Git On Your Own

version control - collaboration: Using Git Together

version control - collaboration - using a shared repository: Using Git Together

version control - collaboration - using forked repositories: Using Git Together

version control - CVS: Using Git On Your Own

version control - decentralized: Using Git On Your Own

version control - Git: Using Git On Your Own

version control - inability to handle office documents: Wrapping Up

version control - Mercurial: Using Git On Your Own

version control - reasons to use: Using Git On Your Own

version control - repository: Using Git On Your Own

version control - Subversion: Using Git On Your Own

version control - systems: Using Git On Your Own

version control - when to commit: Using Git Together

version numbers: Wrapping Up

version numbers - build: Wrapping Up

version numbers - major: Wrapping Up

version numbers - minor: Wrapping Up

version numbers - patch: Wrapping Up

version numbers - semantic versioning: Wrapping Up

Vim editor - exiting: Using Git On Your Own

virtual machine: Tooling

virus scanner: Security

Visual Basic: Software Design

visualization - difficulty of testing: Testing

VS Code: Tooling

Wales, Jimmy: How to be a Good Research Partner

waste (in software development): The Important Stuff

waterfall model: Process

WebAIM WAVE: Software Design, Fair Play

WEIRD: Research

whiteboard coding questions: Fair Play

wiki: Communicating

Wikipedia: How to be a Good Research Partner

Wilson, Greg: Authors

Wilson, Robert: Software Design

Windows: Tooling

workflow (in Git): Using Git On Your Own

workflow diagram: Software Design

working memory: Thinking and Learning

YubiKey: Security