(CS) Learning Note

Sorting Algorithms Sep 3, 2023

Arrays: The Cornerstone of Organized Data Sep 4, 2023

Linked Lists: The Opposite of Arrays Sep 5, 2023

Mastering Linked Lists: Avoiding Common Pitfalls Sep 6, 2023

Stacks and Queues: Operation-Constrained Linear Lists Sep 7, 2023

Recursive Sep 8, 2023

Designing a Generic, High-Performance Sorting Algorithm Sep 9, 2023

Binary Search: The Power of O(log n) Sep 10, 2023

Skip Lists: Binary Search on Linked Lists Sep 11, 2023

Hash Tables: The Backbone of Efficient Data Searching Sep 12, 2023

How to Design a Hash Table Sep 13, 2023

LRU Cache: Synergy of Hash Tables and Linked Lists Sep 13, 2023

Binary Trees: The Most Common Tree Sep 13, 2023

Binary Search Tree: Embodiment of Binary Search Sep 16, 2023

Red-Black Tree: The Most Popular Balancing Binary Search Tree Sep 17, 2023

Graphs: Modelling Pairwise Relations Sep 18, 2023

Graph Traversal: Breadth-First Search and Depth-First Search Sep 19, 2023

What is Software Engineering? Sep 30, 2023

Computer Science Terminology in English and Chinese Oct 1, 2023

Introduction to Project Management Oct 1, 2023

Automated Software Verification Oct 1, 2023

Introduction To Agile Project Management Oct 5, 2023

Modelling Programs with Transition Systems Oct 6, 2023

Linear Temporal Logic (LTL) Oct 8, 2023

Software Modelling and Design Oct 11, 2023

What is Clean Code? Oct 11, 2023

Clean Code: Meaningful Names Oct 13, 2023

Büchi Automaton Oct 15, 2023

Unified Modelling Language (UML) Oct 17, 2023

Use Case Diagrams in UML Oct 17, 2023

Class Diagrams in UML Oct 17, 2023

Clean Code: Functions Oct 18, 2023

Clean Code: Comments Oct 18, 2023

Project Management Process Groups Oct 20, 2023

Initiating Projects (Process Groups) Oct 20, 2023

State Machine Diagrams in UML Oct 21, 2023

Sequence Diagrams in UML Oct 22, 2023

Activity Diagrams in UML Oct 22, 2023

Planning Projects - Scope (Process Groups) Oct 22, 2023

Planning Projects - Schedule (Process Groups) Oct 23, 2023

Clean Code: Formatting Oct 26, 2023

Java Version History Oct 26, 2023

Three Java Platforms: SE, EE, and ME Oct 26, 2023

Explicit State Model Checking Oct 27, 2023

Architectural Design Oct 28, 2023

Clean Code: Objects and Data Structure Oct 29, 2023

Planning Projects - Cost (Process Groups) Oct 30, 2023

Introduction to JVM Oct 30, 2023

Clean Code: Error Handling Oct 31, 2023

How does Java code runs? Nov 1, 2023

Design Patterns Nov 2, 2023

Data Modelling Nov 3, 2023

Symbolic Model Checking Nov 5, 2023

Binary Decision Diagrams Nov 9, 2023

Memory Management in JVM Nov 9, 2023

Security By Design Nov 13, 2023

Planning Projects - Quality (Process Groups) Nov 13, 2023

Planning Projects - Resource (Process Groups) Nov 13, 2023

Planning Projects - Communication (Process Groups) Nov 13, 2023

Planning Projects - Risk (Process Groups) Nov 13, 2023

Clean Code: Boundaries Nov 14, 2023

NuSMV Model Checker Nov 14, 2023

Some Interesting Codes in Java Nov 15, 2023

Some Java basics Nov 18, 2023

Just-In-Time (JIT) Compilation in Java Nov 18, 2023

Introduction to Formal Methods & Event-B Nov 19, 2023

Introduction to Event-B Nov 19, 2023

Relations and Functions in Event-B Nov 19, 2023

SAT Problem and DPLL Nov 20, 2023

Collections in Java Nov 24, 2023

Clean Code: Unit Tests Nov 25, 2023

Bounded Model Checking Nov 25, 2023

Hoare Logic Nov 25, 2023

What Exactly Are We Talking About When Talking About OOP? Nov 27, 2023

Extension Refinement in Event-B Nov 28, 2023

SOLID Principles Nov 28, 2023

For SRP, How Do We Determine If a Class Has a "Single" Responsibility? Dec 3, 2023

For OCP, What Exactly Are "Extensions" and "Modifications"? Dec 4, 2023

Does LSP Conflict with Polymorphism? Dec 5, 2023

For ISP, What Is an "Interface"? Dec 5, 2023

Proof-Based Verification in Event-B Dec 7, 2023

Lists and Collections in Event-B Dec 7, 2023

What gets inverted in DIP? Dec 10, 2023

Why do We Need to Use More Composition and Less Inheritance? Dec 11, 2023

What is Refactoring? Why do We Need Refactoring? Dec 15, 2023

Principles in Refactoring Dec 21, 2023

Limitations in Refactoring Dec 21, 2023

Bad Smells in Code Dec 28, 2023

Software Testing Jan 20, 2024

Threat Modelling Jan 20, 2024

What is TDD (Test-Driven Development)? Jan 25, 2024

Common Commands in JDK Jan 25, 2024

Garbage Collection (GC) in JVM Jan 26, 2024

Null in Java: A Bad Invention. Jan 26, 2024

OOP vs. POP vs. FOP vs. AOP Jan 27, 2024

Clean Code: Classes Jan 31, 2024

Clean Code: Systems Feb 2, 2024

Clean Code: Emergency Feb 17, 2024

Understanding Databases Feb 18, 2024

Is the Index a Panacea? Feb 18, 2024

Reverse Engineering Feb 19, 2024

Clean Code: Concurrency Feb 19, 2024

Multithreading in Java Feb 21, 2024

Different Thread Pools in Java Feb 21, 2024

Locks in Java Feb 22, 2024

Big Refactoring Feb 25, 2024

Getters/Setters Are Evil in OOP Feb 25, 2024

Table Value Parameter (TVP) Mar 3, 2024

Buffer Overflow Attacks Mar 7, 2024

Why I Don't Recommend Using the Singleton Pattern? Mar 13, 2024

Relational Algebra in Databases Apr 7, 2024

Overview of Query Processing in Databases Apr 8, 2024

Cost Estimation: The Basics of Query Optimisation in Databases Apr 8, 2024

Query Optimisation in Databases Apr 9, 2024

Execution Models in Databases Query Processing Apr 10, 2024

Physical Plan in Databases Query Processing Apr 14, 2024

Implementation of the Red-Black Tree May 3, 2024

B+ Tree: How is Indexing of Databases Implemented? May 6, 2024

Relatively Simple String Matching Algorithms: BF and RK Jun 8, 2024

Common String Matching Algorithms: KMP Jun 9, 2024

Algorithmic Thinking: Greedy Jun 10, 2024

Algorithmic Thinking: Divide-and-Conquer Jun 11, 2024

Algorithmic Thinking: Backtracking Jun 14, 2024

Algorithmic Thinking: Dynamic Programming Jun 16, 2024

Comparison of Four Algorithmic Thinking Jun 19, 2024

Bitmap and Bloom Filter Jun 29, 2024

Why do We Need Software Architecture? Jun 30, 2024

Three Principles of Architecture Design Jul 1, 2024

High Performance Architecture: Read-Write Separation Jul 2, 2024

High Performance Architecture: Database Sharding & Partitioning Jul 4, 2024

High Performance Architecture: Caching Jul 5, 2024

High Performance Architecture: Load Balancing Jul 6, 2024

The CAP Theorem: A Crucial Concept for Architects Jul 16, 2024

Why I Think Design Principles Are More Important Than Design Patterns? Sep 18, 2024

(CS) Learning Note 134