🪴 Avril Chen
Search
Search
Search
Dark mode
Light mode
Explorer
Book notes
2024 Reading Progress
Atomic Habits
Deep Work
Digital Minimalism
How to Become A Straight A Student
Jack Recommendations
Slow Productivity
So Good They Can't Ignore You
Stolen Focus
The Rise and Fall of the Third Reich
Tools of Titans
1B Software Engineering
2A Software Engineering
2B Software Engineering
3-SAT
3A Software Engineering
3B Software Engineering
A-Star Algorithm
A1-Canvas
A2-SimpleKit
A3 Mock
A3-Vanilla
A4 User Interface Testing
A4-Preact
A5 Fuzzing
A6 Release Pipeline
A7 Automated Testing Results Analysis
A8 Load Testing - Performance
Abstract Base Class
Abstract Data Type
Accelerated Computing
Accessibility
Action Verbs
Activity 3 - Grand River Watershed Reservoirs Infographic
Activity 5 - Environmental Geology at Home
Adapter Design Pattern
Addition and Substraction
Address Space
Addressing (OS)
Adolf Hitler
ADT Design
Advanced Package Tool
Advices
Aggregation (C++)
Agile
Air Pollution
Alan Silvestri
Alfred Newman
Algorithms
Alternative Energy Sources
ALU
Android
Animation
Aristotle
ARM
Array
Assembler
Assembly
Assembly File
Asymptotic Analysis
Asynchronous
Atom
Automake
Avatar The Way of Water
Average-Case Run-Time
AVL Tree
B-Tree
Backtracking
Basic commands
Bazel
Beckham
Bellman-Ford Algorithm
Bernard Herrmann
Best Picture
BETA Technologies
Bifurcation Diagram
Big Bang
Binary Heap
Binary Search
Binary Search Tree
Binary Tree
Biography
BIOS
Bit
Bit-Wise Operators
Blackberry
Bode Plots
Book Dedications
Books
Books to read
Bootstrap
Boyer-Moore Algorithm
Boyer-Moore Majority Voting Algorithm
Branching
Breadth-First Search
Bridge Design Pattern
Bucket Sort
Buddy System
Build Tool
Byte
Byte Addressable Memory
C Language
C++
C++ Interview Questions
Cache
Cal Newport
Callouts
Ch1 - Computer Abstractions and Technology
Ch2 - Instructions Language of the Computer
Chapter 5 - ECE222
Chapter 6 - COMPARISON METHODS – RATE OF RETURN (ROR) ANALYSIS
Chapter 7 - Comparison Methods - Rate of Return (ROR) Analysis
Chess MOC
Chess-Engine
China
chip card
chmod
Chris Lattner
Christopher Nolan
CISC
Clang
Climate
CMake
Coastal Zones and Processes
Code Coverage
Code Generation
Coin Problem
Comparison-Based Algorithm
Compile Time vs. Runtime
Compiled vs Interpreted Language
Compiler
Compiler Optimization
Complex Number
Complex Plane
Composition (C++)
Compressed Trie
Computer Programs
Concurrency
const keyword
Constructor
Container
Context Sensitive Analysis
Context-Free Languages and Parsing
Control Flow Graph
Convolution
Cookies
Copy Assignment Operator
Copy Constructor
Copy-and-Swap Idiom
Copyright
Core
Core Systems
CPI
CPU
Creative Commons License
Credit Card
Cross-Compilation
CS 247 Lecture 2
CS 247 Lecture 3
CS137 - Programming Principles
CS138 - Introduction to Data Abstraction and Implementation
CS240 - Data Structure and Data Management
CS241 - Foundations of Sequential Programs
CS247 - Software Engineering Principles
CS247 final practice
CS247 Lecture 1
CS247 Lecture 4
CS247 Lecture 5
CS247 Lecture 6
CS247 Lecture 7
CS247 Lecture 8
CS247 Lecture 9
CS247 Lecture 10
CS247 Lecture 11
CS247 Lecture 12
CS247 Lecture 13
CS247 Lecture 14
CS247 Lecture 15
CS247 Lecture 16
CS247 Lecture 17
CS247 Lecture 18
CS247 Lecture 19
CS247 Lecture 20
CS247 Lecture 21
CS247 Lecture 22
CS247 Lecture 23
CS247 Lectures
CS247 Midterm
CS341 - Algorithms
CS343 - Concurrent and Parallel Programming
CS348 - Introduction to Database Management
CS349 - User Interfaces
CS349 Study Questions
Csmith
CSS
Cuckoo Hashing
CUDA Compiler
Cumulative Distribution Function
Curiously Recurring Template Pattern
Current Uses
Danny Elfman
Data Definition Language
Data Flow Graph
Data Manipulation Language
Data Structure
Database
Database Management System
Database System
Datapath
David Raksin
Deadlock
Decision Tree
Decorator Design Pattern
Dekker's Algorithm
Denis Villeneuve
Depth-First Search
Deque
Derek Gibberish
Derivative Work
Design a Vending Machine
Design Pattern
Design Questions
Destructor
DFA
Diamond Problem
Dictionary
Differential Equations
Dijkstra
Dijkstra’s Algorithm
Dimitri Tiomkin
Direct Memory Access
Directed Graph
Dispatcher
Divide and Conquer
Docker
Document Object Model
DRAM
Drawing
Dune
Dunkirk
Dynamic Linking
Dynamic Ordering
Dynamic Programming
dynammic
Earliest Deadline First
Earliest Known Life Forms
Earth
Earthquake
ECE Concepts
ECE105
ECE105 - Classical Mechanics
ECE106 - Electricity and Magnetism
ECE124
ECE140
ECE192 - Engineering Economics and Impact on Society
ECE192 Assignment
ECE222
ECE358
ECE358 - Computer Networks
Edit Distance
Eigen
Elements
Elision
Elmer Bernstein
Embedded SQL
Émile Roy
Emily
Encapsulation
End-User License Agreements
Ennio Morricone
Entity-Relationship Model
Enumeration
Erich Korngold
ES Module
Ethics
Exception Handling
Exception Handling (OS)
Exception Safety
Execution of Operating System
Expected Run-time
explicit keyword
External Fragmentation
Fair Dealing
Fault Tolerance
Filesystem
Film and TV
Final Review CS247
Final Study CS341
Final Study CS349
Final Study SE350
Final Study SE465
Final Value Theorem
find
Finite Language
First-Fit Allocation
Five-State Model
Flash
Focus
Ford Motor Company
Formal Languages
Forward Declaration
Fossil Fuels
Fourier Series
Fourier Transform
Fran Lebowitz
Friend (C++)
Function Overloading
Function Overriding
Function Pointer
Fuzzing
Galaxie
Game of Thrones
GCC
GDB
General MOC
Geography
Geoguessr
Geology
German
Germany MOC
Git
git bisect
Git Common Issues
Git Merge vs Git Rebase
git stash
Glaciers and Deserts
GNU
GNU toolchain
GPU
GraalVM
Graph
Graph Database
Graph Representation
Graph Theory
Graphical User Interface
Greedy Algorithms
Greedy Best-First Search
Green Book
Grouwdwater and Water Resources
Hamiltonian Path
Handshaking Lemma
Hans Zimmer
HapiGPT
Hardware
Hardware Virtualization
Hash Collision
Hash Table
Hashing
Hashing with Chaining
HDD
Header File
Heap
Heap (Memory)
Heap Sort
Heapify
Hexadecimal Notation
Hit-Test
Hitler
Hockey
How to become a straight a student
HTML
htop command
Huffman Tree
Human Evolution
Hypervisor
I-O Modules
Illegal Uses of Social Media
Induction
Inheritance
Initial Value Theorem
Insertion Sort
Integration By Parts
Integration Order
Intellectual Property
Intermittent Fasting
Internal Fragmentation
Interpolation Search
Interrupts
Interview Questions
Intuition
Invariant
Inverse Laplace Transform
Investigating Language and Meaning Making
Ion
ISA
Isaac Newton
Iterator Design Pattern
JaCoCo
jalr
James Cameron
James Horner
Japan
Java
Java Virtual Machine
JavaScript
Jenkins
Jerry Goldsmith
John Barry
John Stuart Mill
John Williams
Jump Register
JUnit
Just-in-Time
Kant
Karatsuba Algorithm
Karp-Rabin Algorithm
kd-Tree
Kernel
Kernel-Level Thread
kill command
Knapsack Problem
Knuth-Morris-Pratt Algorithm
Korasaju's Algorithm
Kotlin
Kruskal's Algorithm
Language
Laplace Table
Laplace Transform
Lecture 1 - Data Representation
Lecture 1 - Scores
Lecture 2 - MUSIC246
Lecture 2 - Rhetoric in Ancient Greek
Lecture 3 - CS241
Lecture 4 - MUSIC246
Lecture 4 - Procedures
Lecture 4 ECE222
Lecture 5 - ECE222
Lecture 5 - Erich Korngold and The Adventures of Robin Hood
Lecture 5 - machine code
Lecture 6 - CS241
Lecture 6 - MUSIC246
Lecture 7 - MUSIC246
Lecture 7 - NFAs
Lecture 8 - DFA's
Lecture 8 - MUSIC246
Lecture 9 - MUSIC246
Lecture 10 - MUSIC246
Lecture 11 - MUSIC246
Lecture 12 - MUSIC246
Lecture Notes Week 3 Technical Details, How's It's Done
Lectures2, 3 - Machine Language
Legal Rules vs. Legal Standards
Libuv
License
Linked List
Linking
Linux
Liskov Substitution Principle
List
Live To 100
Livelock
Livres Marquants
LL(1) Top-Down Parsig
LLVM
Load Immediate
Loading and Linking
lock (C++)
Logical Mapping
Longest Common Subsequence Problem
Lowest Common Ancestor
LSD-Radix Sort
MAC
MAC Address
Machine and Assembly Language
Magma
Main Memory
Make It Stick
Makefile
Maps of Content MOC
Marmoset
Mashup
Mass Movements
Massachusetts Institute of Technology
Master Recursion
Master Theorem
Masters of the Air
MATH115 - Linear Algebra for Engineering
MATH117 - Calculus 1 for Engineering
MATH119 - Calculus 2 for Engineering
MATH135 - Algebra for Honours Mathematics
MATH213 - Signals, Systems, and Differential Equations
MATH213 Final
MATH239 - Introduction to Combinatorics
Maven
Max Deutsch
Max Steiner
Max Winkler
Maximum Subarray
Median of medians
Memory
Memory Allocation
Memory Management
Memory Management Unit
Memory Partitioning
Merge Sort
MERL
Message Passing
Michael Brown
Microkernel
Middleware
Midterm CS341
Midterm Practice CS247
Midterm SE212
Miklos Rosza
Mineral
Mineral and Rock Resource
Minimum Spanning Tree
MIPS
MIPS Assembler
MIPS Language
Misaligned Memory
Misophonia
Mocking
Model View Controller
Module 4 Theories
Modules and Interfaces
Monitors
Monolithic Kernel
Montreal
Moral Rights
Mother Tongue
Move Assignment Operator
Move Constructor
Movies
MSD-Radix Sort
Multicore Processor
Multiply and Divide
Multiprogramming
Multithreading
Multiway Trie
Museum of Fine Arts
Music
MUSIC246 - Film Scores
Mutation Testing
mutex (C++)
Mutual Exclusion
Native Image
Natural Deduction
Nazi Germany
Nibble
nice command
Node.js
NP
NP-Complete
NP-Hard
Nuremburg trials
Object Relation Diagram (ORD)
Object-Oriented Programming
Observer Design Pattern
On Reading
Open Source License
Open Source Software
Open-Closed Principle
Operating System
Operation Barbarossa
Ordinary Differential Equations
OS Images
OS Power Saving
Oscars
OTP
Outer Join Examples
Outline 3min
Paging
Painter Algorithm
parallelism
Partial Fractions
Partition Algorithm
Patent
PD10 - Professional Responsibility in Computing
PD11 - Processes for Technical Report Writing
Peer feedback
Peer Feedback Assignment 2
Persuasive Speech Outline
Philosophy
Pipelining
Planar Graph
Plate Tectonics
Pocket Ereaders
Pointer
Polymorphism
Population Growth
Porting
POSIX
Power
Preact
Preprocessor
Pretend it's a City
Prim's Algorithm
printed circuit boards
Priority Queue
Probability Mass Function
Probe Sequence
Procedures
Process
Process Control
Process Control Block
Process Image
Process Table
Processor
Producer and Consumer Problem
Product Liability
Product Management
Productivity
Productivity MOC
Program Counter
Programming Embedded Systems
Proof Theory
Proposititional logic
Public Domain
Public Speaking
Python
QEMU
QNX
Quadtree
Queen's Gambit
Quentin Tarantino
Queue
Quick Sort
Quickselect
R-type instructions
Race Condition
Radiometric Dating
RAM
Ramin Djawadi
Random Variables
Randomized Algorithms
Range Searching
Range Tree
Rapyuta Robotics
Raspberry Pi
Reader-Writers Problem
Reading Biographies To Trigger Inspiration
Real-Time Operating System
Recurrence Relations
Recursion
Recursion-Tree Method
Reel Music Exploring 100 Years of Film Music
Register File
register keyword
Registers
Regular Language
Relational Calculus
Relational Database
Relaxation
Representation Exposure
Representation Invariants and Abstraction Functions
Resource Acquisition is Initialization
Resume
Revision 2022
RISC
RISC-V
RISC-V ISA
Rize
Robot Operating System (ROS)
Robotics
Rock
ROM
Rule of Five
Run-time Analysis
Running
Rust
RV32I
RV64I
Safety Software
Sanitizers
sb
Scheduler (OS)
SCI250 - Environmental Geology
Scientific Method
SE
SE101 - Introduction to Methods of Software Enginerring
SE212
SE350 - Operating Systems
SE350 Labs
SE380 - Introduction to Feedback Control
SE390 - Design Project Planning
SE464 - Software Design and Architectures
SE465 - Software Testing and Quality Assurance
Searching Algorithms
Segmentation
Selection Algorithm
Selection Sort
Semantics
Semaphore
Shared Pointer
Shell
Shell Commands
sign extention
Signal
Signals
Signed integers
Silicon die
SimpleKit
Single Responsibility Principle
Skip List
Sliding Window
Smart Pointer
Snowboarding
So many books so little time
Socket
Software Errors
Software Quality
Software Quality Assurance
Software Testing
Soil Erosion
Solar System
Solo Travel
SONAME
Sorting Algorithms
Sorting Permutation
Spanning Tree
Spooktober Challenge 2023
Sports
SQL Data Types
SQL Joins
SRAM
Stack
Stacking
Standard Template Library
STAT206
Static Analyzer
static keyword
Static Linking
Static Ordering
Static vs. Dynamic Dispatching
Static vs. Dynamic Type Pointer
Steven Spielberg
Strassen Algorithm
Strategy Design Pattern
Streams and Flooding
String Matching
String Matching with Finite Automata
Strong Connectivity
Struct
Structured Query Language
Subset
Succession
Summation
Swift
Symmetric Multiprocessing
sync command
Syntax
System Bus
System Call
System Design Questions
Tail Recursion
Tampering and Forgery
Task
Task Control Block
TCB
Template (C++)
Template Method Design Pattern
Tenet
Tennis
Tensorflow
Test Smells
The Banshees of Inisherin
The Barbershop
The Big Five
The Evolution of Human Rights
The Last of Us
The Social Dilemma
The Uncanny Valley
Thread
Time-Sharing
tinyxml2
Tips
Tips to do as a junior engineer
Toolchain
Top Interview 150
Topological Ordering
Tortious vs. Contractual Liability
Totalitarianism
TPU
Tracking
Trade Secret
Transactions
Transfer Function
Transformational Proof
Transistor
Transpose Heuristic
Treaty of Versailles
Tree
Tree Algorithms
Tree Rotation
Trie
TruffleRuby
Two-State Process Model
Two's Complement
typedef
TypeScript
uC++
UML
UML Modelling
Undirected Graph
Undo
Unique Pointer
Unit Testing
University of Waterloo
Unix
Unsigned integers
Untitled
User Interface Testing
User-Generated Content Exception
User-Level Thread
Valgrind
Value Categories
Value Category
Vangelis
Vector
Virtual Inheritance
Virtual Machine
Virtual Memory
Virtual Method
Virtualization
Visitor Design Pattern
Vite
volatile keyword (C)
Volcano
Von Newmann Architecture
Wafer
WARG
Warranty
Waste
Water Pollution
Waterfall Method
Waterloo Software Engineering
Week 2 - 3B
White Path Lemma
Why read
Window Manager
Windows
Work Progress
Work Term 5
World War II
Emily Cai
Graph View
Backlinks
CS349 - User Interfaces