🪴 Avril Chen
Search
Search
Search
Dark mode
Light mode
Explorer
Assignments
A1-Canvas
A2-SimpleKit
A3 Mock
A3-Vanilla
A4 User Interface Testing
A4-Preact
A5 cs343
A5 Fuzzing
A6 cs343
A6 Release Pipeline
A7 Automated Testing Results Analysis
A8 Load Testing - Performance
Activity 3 - Grand River Watershed Reservoirs Infographic
Activity 5 - Environmental Geology at Home
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
SE
1B Software Engineering
2A Software Engineering
2B Software Engineering
3A Software Engineering
3B Software Engineering
4A Software Engineering
_Accept
3-SAT
A-Star Algorithm
ABA problem
Abstract Base Class
Abstract Data Type
Accelerated Computing
Accessibility
Action Verbs
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
Android
Animation
Arbiter
Aristotle
Arithmetic Logic Unit
ARM
Array
Articles
Assembler
Assembly
Assembly File
Assignment 1 - Theories of Law
Asymptotic Analysis
Asynchronous
Atom
Austin
Automake
Avatar The Way of Water
Average-Case Run-Time
AVL Tree
await
B-Tree
Backtracking
Bakery Algorithm
Barging
Bari Trip
Barrier
Base Power
Base Power Interview
Basic commands
Batttery
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
Boost Library
Bootstrap
Border Gateway Protocol
Boyer-Moore Algorithm
Boyer-Moore Majority Voting Algorithm
Breadth-First Search
Bridge Design Pattern
Bucket Sort
Buddy System
Build Tool
Busy Waiting
Byte
Byte Addressable Memory
C Language
C++
C++ Interview Questions
Cache
Cal Newport
California Trips
Ch1 - Computer Abstractions and Technology
Ch2 - Instructions Language of the Computer
Chapter 5 - ECE222
Chess-Engine
China
chip card
chmod
Chris Lattner
Christopher Nolan
Circuit-Switching
CISC
Clang
Classical Legal Positivism
Climate
CMake
Coastal Zones and Processes
Code Coverage
Code Generation
Coin Problem
Colonialism and Sovereignties of Law
Comparison-Based Algorithm
Compile Time vs. Runtime
Compiled vs Interpreted Language
Compiler
Compiler Interviews
Compiler Optimization
Complex Number
Complex Plane
Composition (C++)
Compressed Trie
Computer Programs
Conan O'Brien
Concurrency
Condition Lock
Congestion Control
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
Coroutine
CPI
CPU
Creative Commons License
Credit Card
Cross-Compilation
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 2
CS247 Lecture 3
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
CS343 Midterm Study
CS348 - Introduction to Database Management
CS349 - User Interfaces
CS349 Study Questions
CS370 - Numerical Computation
Csmith
CSS
Cuckoo Hashing
CUDA
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
Datadog
Datapath
David Raksin
Deadlock
Decision Tree
Decker's Algorithm
Decorator Design Pattern
DeepSeek
Dekker's Algorithm
Denis Villeneuve
Depth-First Search
Deque
Derek Gibberish
Derivative Work
Design a Vending Machine
Design Pattern
Design Questions
Destructor
DHCP
Diamond Problem
Dictionary
Differential Equations
Dijkstra
Dijkstra’s Algorithm
Dimitri Tiomkin
Direct Memory Access
Directed Graph
Dispatcher
Distributed Systems
Divide and Conquer
Docker
Document Object Model
Domain Name System
DRAM
Drawing
Dune
Dunkirk
Dynamic DNS
Dynamic Linking
Dynamic Ordering
Dynamic Programming
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 - Computer Networks
Edit Distance
Eigen
Elements
Elision
Elmer Bernstein
Email, SMTP, IMAP
Embedded SQL
Émile Roy
Encapsulation
End-User License Agreements
Ennio Morricone
Entity-Relationship Model
Enumeration
Erich Korngold
ES Module
Ethernet
Ethics
Exception Handling
Exception Handling (OS)
Exception Safety
Execution of Operating System
Expected Run-time
explicit keyword
External Fragmentation
External Scheduling
Factory Method
Fair Dealing
Fault Tolerance
Feminist Legal Theory and Intersectionality
Fiber To The Home
Filesystem
Film and TV
Final Review CS247
Final Revision 3B
Final Study CS341
Final Study CS343
Final Study CS349
Final Study ECE358
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
Forwarding
Forwarding Table
Fossil Fuels
Fourier Series
Fourier Transform
Fran Lebowitz
Frequency Division Multiplexing
Friend (C++)
Function Overloading
Function Overriding
Function Pointer
Future
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
Golang
GPU
GraalVM
Graph
Graph Database
Graph Representation
Graph Theory
Graphical User Interface
Greece Trip
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
Hisense Touch Lite
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
In Cold Blood
Induction
Inheritance
Initial Value Theorem
Insertion Sort
Integration By Parts
Integration Order
Intellectual Property
Intermittent Fasting
Internal Fragmentation
Internal Scheduling
Internet
Internet Service Provider
Interpolation Search
Interrupts
Interview Questions
Introduction to the QNX RTOS with Raspberry Pi
Intuition
Invariant
Inverse Laplace Transform
Investigating Language and Meaning Making
Ion
IPv4
ISA
Isaac Newton
Iterator Design Pattern
JaCoCo
jalr
James Cameron
James Horner
Japan
Java
Java Virtual Machine
JavaScript
Jenkins
Jensen Huang
Jerry Goldsmith
John Barry
John Stuart Mill
John Williams
Jump Register
JUnit
Just-in-Time
Justice, Fairness, Equality
Kant
Karatsuba Algorithm
Karl Marx
Karp-Rabin Algorithm
kd-Tree
Kernel
Kernel-Level Thread
kill command
Knapsack Problem
Knuth-Morris-Pratt Algorithm
Korasaju's Algorithm
Kotlin
Kruskal's Algorithm
Labs ECE358
LAN
Language
Laplace Table
Laplace Transform
Law's Environment
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 Realism
Legal Rules vs. Legal Standards
Libuv
License
Linearization
Link Layer
Linked List
Linking
Linux
Liskov Substitution Principle
List
Live To 100
Livelock
Livres Marquants
LL(1) Top-Down Parsig
LLVM
Load balancing
Load Immediate
Loading and Linking
Lock
Logical Mapping
Long Answers CS343
Longest Common Subsequence Problem
Lowest Common Ancestor
LS101 - Introduction to Legal Studies
LSD-Radix Sort
MAC
MAC Address
Machine and Assembly Language
Magma
Main Memory
Make It Stick
Makefile
Map
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 CS343
Midterm ECE358
Midterm ECE358 Solutions
Midterm MATH213
Midterm Practice CS247
Midterm SE212
Midterm Study 3B
Miklos Rosza
Mineral
Mineral and Rock Resource
Minimum Spanning Tree
MIPS
MIPS Assembler
MIPS Language
Misaligned Memory
Misophonia
Mocking
Model View Controller
Modem
Module 4 Theories
Modules and Interfaces
Monitor (Synchronization)
Monitors (SE350)
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
N-Thread Mutual Exclusion
Native Image
Natural Deduction
Natural Law Theory
Nazi Germany
Network Applications
Network core
Nibble
nice command
Node.js
Nonlocal Transfer
NP
NP-Complete
NP-Hard
Nuremburg trials
NVDIA DRIVE
NVIDIA Internship
NVIDIA Onboarding
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
Owner Lock
Packet-Switching
Paging
parallelism
Partial Fractions
Partition Algorithm
Patent
PD8 - Intercultural Skills
PD10 - Professional Responsibility in Computing
PD11 - Processes for Technical Report Writing
Peer feedback
Peer Feedback Assignment 2
Permutation
Persuasive Speech Outline
Petition for Exception to Academic Regulations
pgx
Philosophy
Physical Layer
Pipelining
Planar Graph
Plate Tectonics
Pocket Ereaders
Pointer
Polymorphism
Population Growth
Porting
POSIX
Power
Power, Violence and Social Norms
Preact
Prefething
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
Project Task 2
Proof Theory
Proposititional logic
Protocol Layering
Public Domain
Public Speaking
Python
QEMU
QNX
QNX Everywhere
QNX RTOS
Quadtree
Queen's Gambit
Quentin Tarantino
Queue
Quick Sort
Quickselect
R-type instructions
Race Condition
Racing
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
Reading Log
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
Root Locus
Router
Routing
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
SE463 - Software Requirements Specification and Analysis
SE464 - Software Design and Architectures
SE465 - Software Testing and Quality Assurance
SE490 - Design Project 1
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
Socket Programming
Software Errors
Software Quality
Software Quality Assurance
Software Testing
Soil Erosion
Solar System
SOLID Design Principles
Solo Travel
SONAME
Sorting Algorithms
Sorting Permutation
Spacemacs
Spaces of Law
Spanning Tree
Spatial Justice
Spooktober Challenge 2023
Sports
SQL Data Types
SQL Joins
SRAM
Stack
Stacking
Standard Template Library
Starvation
STAT206
State Space Form
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
Stripe
Strong Connectivity
Struct
Structured Query Language
Subset
Succession
Summation
Swift
Switch
Symmetric Multiprocessing
sync command
Synchronization Lock
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 Power of 10 Rules
The Social Dilemma
The Study of Law
The Token Economy
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
Train for 10K
Train for Half Marathon
Transactions
Transfer Function
Transformational Proof
Transistor
Transmission Control Protocol
Transpose Heuristic
Treaty of Versailles
Tree
Tree Algorithms
Tree Rotation
Trie
TruffleRuby
Two-State Process Model
Two's Complement
typedef
TypeScript
uC++
uCondition
UML
Undirected Graph
Undo
Unique Pointer
Unit Testing
University of Waterloo
Unix
Unsigned integers
Untether AI
Untether AI Interview
Untitled
User Datagram Protocol
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
WARG
Warranty
Waste
Water Pollution
Waterfall Method
Waterloo Software Engineering
Web and HTTP
Westerns
White Path Lemma
Why read
WiFi
Window Manager
Windows
Wireless Network
Work Progress
World War II
Stripe
Would love to intern at the company given the chance. #todo
Graph View
Backlinks
No backlinks found