Computer Science 101: Master the Theory Behind Programming
You’ll start by learning about binary numbers, the backbone of how computers store and process data.
From there, the course dives into analyzing algorithms using concepts like time complexity, Big O notation, and mathematical functions like logarithms and factorials.
The meat of the course covers essential data structures like arrays (fixed, circular, and dynamic), linked lists (singly and doubly linked), stacks, queues, and trees (binary search trees).
You’ll learn how to implement these structures, analyze their time complexities, and see real-world examples of their applications.
Moving on, you’ll tackle sorting algorithms – bubble sort, selection sort, insertion sort, quick sort, and merge sort.
The course explains the pros and cons of each algorithm, their stability characteristics, and how to code them efficiently.
Graph theory is another key topic, covering graph types, terminology, depth-first and breadth-first searches, and their time complexities.
The course also explores hashing algorithms, hash tables, collision handling techniques (like linear probing and rehashing), and the differences between hashing and encryption.
Throughout the course, you’ll find coding examples, quizzes to reinforce concepts, and real-world use cases that tie the theoretical knowledge to practical applications.
Additionally, there are bonus lectures on topics like binary-to-hexadecimal conversion and optimization problems.
Database Management System from scratch - Part 1
You’ll begin by exploring data models and their types, laying the foundation for the Entity-Relationship (ER) model.
The course dives deep into the ER model, explaining entities, relationships, and attributes from a database designer’s perspective.
You’ll learn about simple and complex attributes, as well as stored and derived attributes.
Next, you’ll delve into the intricacies of relationships, including their degree, cardinality ratio, and types like total and partial participation.
The course provides ample examples to illustrate these concepts, ensuring you grasp them thoroughly.
Moving on, you’ll study the relational model, a crucial aspect of database management.
You’ll understand tuples, fields, domains, and the distinction between entities and entity types.
The course explains how the relational model is derived from discrete mathematics and covers its essential rules.
The syllabus then focuses on the constraints of the relational model, such as domain constraints and key constraints.
You’ll learn about super keys, candidate keys, and primary keys, with numerous examples to reinforce your understanding.
Furthermore, you’ll explore key constraints, entity integrity constraints, foreign keys, and referential integrity constraints.
The course covers scenarios where constraints are violated during insertion, deletion, and updation, and how the DBMS handles these situations.
The conversion of the ER model to the relational model is another important topic covered in the course.
You’ll learn how to convert entities, attributes, and relationships, including one-to-many, one-to-one, and many-to-many relationships.
Functional dependencies, a fundamental concept in database management, are also covered in detail.
You’ll learn about trivial, non-trivial, and semi-trivial functional dependencies, as well as closure sets and their applications.
The course also teaches you how to find keys using closure operations, with numerous examples and problems to practice.
Additionally, you’ll learn about equivalence and minimization of functional dependency sets using closure.
Finally, the course provides guidance on how to proceed further in your database management journey, ensuring you have a solid foundation to build upon.
Operating Systems from scratch - Part 1
You’ll start by understanding the basic structure of computer systems and how hardware devices interact.
This lays the foundation for grasping the need for operating systems and their role in managing resources efficiently.
The course then dives into the core concepts of operating systems, such as processes, process states, and process control blocks.
You’ll learn about different types of operating systems and the importance of scheduling algorithms like Shortest Job First (SJF), Shortest Remaining Time First (SRTF), and First Come First Served (FCFS).
Practical examples and assignments will help you grasp concepts like response time and context switching.
As you progress, you’ll explore advanced scheduling algorithms like Longest Job First (LJF), Longest Remaining Time First (LRTF), priority-based scheduling, and Highest Response Ratio Next (HRRN).
The course covers their advantages, limitations, and practical implementations, ensuring you understand the trade-offs involved.
Moving on, you’ll delve into the basics of number systems, particularly binary numbers, which are crucial for understanding memory allocation techniques.
You’ll learn about contiguous and non-contiguous memory allocation, fixed and variable partitioning, and memory allocation algorithms.
The course also touches on the need for paging, a fundamental concept in modern operating systems.
Additionally, you’ll gain insights into process state diagrams, dispatcher operations, and the importance of suspend ready and suspend I/O states.
Throughout the course, you’ll encounter practical examples, assignments, and real-world scenarios that reinforce your understanding of the concepts.
The syllabus is designed to provide a solid foundation in operating system principles, preparing you for more advanced topics in subsequent courses.
Data Structures & Algorithms Essentials using C++ (2023)
This comprehensive syllabus covers a wide range of topics that are essential for any aspiring programmer or computer science student.
The course starts with the fundamentals of arrays, including input/output operations, searching (linear and binary), and various array problems like reversing, printing pairs/subarrays, and finding subarray sums using different approaches like brute force and prefix sums.
You’ll also learn about the powerful vector data structure from the Standard Template Library (STL).
Next, you’ll dive into sorting algorithms like bubble sort, insertion sort, selection sort, and more advanced ones like merge sort and quick sort.
The syllabus also covers character arrays/strings, teaching you how to work with strings using C++ string functions and the string class from STL.
Moving on, you’ll explore 2D arrays, pointers, dynamic memory allocation, and the vector class implementation.
The course covers crucial topics like bit manipulation techniques (left/right shift, getting/setting bits, etc.)
and recursion, including recursive problems like fibonacci series, sorted array check, and number spelling.
The syllabus dives deep into divide-and-conquer algorithms like merge sort and quick sort, as well as backtracking techniques for solving problems like N-Queens, Sudoku, and finding subsets/permutations.
You’ll also learn about space and time complexity analysis using Big O notation.
Object-Oriented Programming (OOP) concepts are covered, including classes, objects, constructors, copy constructors, and destructors.
Data structures like linked lists, stacks, queues, binary trees, binary search trees (BSTs), heaps/priority queues, hashing (hash functions, collision handling, load factor, rehashing), and tries are explored in detail.
The course introduces you to graphs, covering representations like adjacency lists, traversal algorithms (BFS, DFS), topological sorting, and Dijkstra’s algorithm.
Dynamic programming concepts are taught through problems like coin change, longest common subsequence (LCS), knapsack, and more.
Finally, you’ll work on a project to implement a shopping cart backend using OOP and data structures, giving you hands-on experience in applying the concepts learned.
Discrete Mathematics
Discrete Mathematics is a foundational course that covers a wide range of topics essential for computer science.
You’ll start by exploring sets, which are the building blocks of many advanced concepts.
The course covers set operations like union and intersection, as well as set properties and Venn diagrams for visualizing relationships.
Next up is logic, a crucial tool for analyzing programs and designing circuits.
You’ll learn about statements, truth tables, logical equivalences, and conditional statements.
The section on digital logic circuits introduces concepts like Boolean expressions and gate operations like NAND and NOR.
Number theory dives into the properties of integers, including divisibility, prime numbers, and methods for finding the greatest common divisor (GCD) and least common multiple (LCM).
This leads into an extensive look at proofs, covering direct proofs, proof by contrapositive, induction, and more.
Functions are explored in-depth, from evaluating and graphing to composition, inverses, and special types like injective (one-to-one) and surjective (onto) functions.
You’ll even practice long division of polynomials.
Relations are then covered, including properties like reflexivity and transitivity, as well as equivalence relations and classes.
Graph theory is a major topic, introducing graphs, subgraphs, isomorphism, and problems like finding Hamiltonian circuits or the shortest path.
Statistics fundamentals like mean, median, outliers, and standard deviation are included.
Combinatorics explores factorials, permutations, combinations, and principles like the pigeonhole principle and Pascal’s triangle.
Finally, you’ll study sequences and series, covering arithmetic and geometric progressions along with finding their partial sums.
Graph Theory Algorithms
You’ll begin your journey by exploring the fundamentals of graph theory and its applications.
The introduction chapter covers the basics, including graph representations and search algorithms like Depth-First Search (DFS) and Breadth-First Search (BFS).
You’ll even learn how to use BFS to find the shortest path on a grid.
Next, you’ll dive into tree algorithms, a crucial subset of graph theory.
From understanding how trees are stored in a computer to identifying isomorphic trees and finding their centers, you’ll gain a solid grasp of these essential data structures.
The course then takes you through a series of classic graph theory algorithms, starting with topological sorting for Directed Acyclic Graphs (DAGs).
You’ll learn algorithms for finding shortest and longest paths, like Dijkstra’s and Bellman-Ford, as well as the Floyd-Warshall algorithm for all-pairs shortest paths.
The source code for these algorithms is also provided, allowing you to see their practical implementation.
You’ll explore algorithms for identifying bridges and articulation points, Tarjan’s algorithm for strongly connected components, and even tackle the famous Travelling Salesman problem.
The course also covers Eulerian paths and circuits, a fundamental concept in graph theory.
Moving on, you’ll delve into the world of network flow, a crucial area with applications in transportation, logistics, and more.
You’ll learn about maximum flow algorithms like Ford-Fulkerson and Edmonds-Karp, as well as capacity scaling and Dinic’s algorithm.
Bipartite matching problems, like the “mice and owls” and “elementary math” problems, are also covered.
Finally, the bonus topics section introduces you to the Union-Find data structure, Kruskal’s and Prim’s algorithms for finding Minimum Spanning Trees, the sparse table data structure, and the Lowest Common Ancestor (LCA) problem.
Computer Science 101 - Computers & Programming for Beginners
You’ll start with an introduction that covers the basics - what a computer is, what it can and cannot do, and how we communicate with these machines.
This lays the foundation for understanding why computer science and programming are so important in today’s world.
Next up is the core programming section.
You’ll learn about fundamental concepts like algorithms, programs, variables, constants, methods, functions, loops, conditional statements, subroutines, and jumps.
These building blocks are essential for writing code.
The course then dives into different programming paradigms - imperative, declarative, and object-oriented programming (OOP).
OOP is a widely-used approach that models real-world objects in code.
You’ll also explore pseudocode, which bridges the gap between human and machine languages.
To reinforce your learning, there’s an extensive glossary covering terms from A to Z. Concepts like algorithms, APIs, bugs, compilers, debugging, errors, frameworks, functions, IDEs, interpreters, programming languages, REPLs, strings, syntax, types, and values are all explained.
The syllabus is designed to take you from having little to no experience to developing a solid grasp of computer science fundamentals.
You’ll be able to understand how computers operate and communicate with them through programming.
Computer Architecture & Organization Part 1 : Cache Memory
This comprehensive syllabus covers various mapping techniques used in cache memory, an essential concept in computer architecture.
The course begins with an introduction to direct mapping, where you’ll learn the basic idea through examples.
It then dives into solving problems related to direct mapping, covering important points like the number of comparators, size of comparators, and the disadvantage of direct mapping compared to other techniques.
Next, you’ll explore associative mapping, another mapping technique used in cache memory.
The syllabus includes lectures explaining associative mapping and its nuances, followed by a dedicated section with problems to reinforce your understanding.
The course then moves on to set associative mapping, a hybrid approach combining aspects of direct and associative mapping.
You’ll learn how set associative mapping works, calculate the number of comparators and conflict misses, and practice with a set of problems specific to this technique.
As you progress, you’ll encounter advanced problems that test your grasp of all the mapping techniques covered so far.
These challenging exercises will solidify your knowledge and prepare you for real-world scenarios.
The syllabus also covers the difference between words and bytes in computer memory, addressing systems (byte and word addressable), and how these concepts relate to cache memory organization.
Importantly, the course delves into cache replacement policies, which determine how data is replaced in the cache when it becomes full.
You’ll learn about popular algorithms like Least Recently Used (LRU), First-In-First-Out (FIFO), and Most Recently Used (MRU), and how they apply to associative and set associative mapping.
Throughout the course, you’ll encounter numerous problems and exercises that reinforce the concepts covered in each section.
These hands-on activities will help you gain a deeper understanding of cache memory and its implementation.
Computer Hardware, Operating System and Networking
You’ll start by diving into computer architecture and motherboard technologies, gaining an understanding of the fundamental components that make up a computer system.
From there, you’ll explore processor and memory technologies, learning about the hardware that powers modern computers.
It also delves into storage technologies, including hard disks, floppy disks, and optical storage.
You’ll learn about the inner workings of these devices and how they store and retrieve data.
Moving on, you’ll gain insights into the power supply and BIOS (Basic Input/Output System), which are crucial for booting up and managing your computer’s hardware.
The syllabus even covers safe mode boot options and troubleshooting techniques, equipping you with the skills to diagnose and resolve common hardware and software issues.
The course also covers peripheral devices like printers and scanners, teaching you about their hardware components and how to set them up and maintain them.
But hardware is just one part of the equation.
The syllabus also focuses on operating systems, with a particular emphasis on Windows 10.
You’ll learn how to install and configure Windows 10, manage user accounts, and implement security policies.
Additionally, you’ll gain hands-on experience with disk management, patch management, and working with virtual machines using VMware Workstation.
Networking is another crucial aspect covered in this course.
You’ll explore network topologies, interconnecting devices, and the OSI (Open Systems Interconnection) model, which provides a conceptual framework for understanding how networks function.
IP address management is also covered, giving you the knowledge to configure and manage network addresses effectively.
Rounding out the syllabus is a section on antivirus technologies, ensuring you understand the importance of protecting your systems from malware and other cyber threats.
The Foundations of Computer Design
You’ll start by exploring how numbers are represented and manipulated using binary and hexadecimal systems.
From there, you’ll dive into the building blocks of digital circuits - logic gates like AND, OR, and XOR gates.
As you progress, you’ll learn to construct more complex components like adders, decoders, and multiplexers using these gates.
The course then guides you through designing essential computer components like latches, registers, and memory units.
You’ll even get hands-on experience with basic MIPS programming and machine language instructions for operations like addition, subtraction, and memory access.
But the real highlight is designing a complete, programmable computer from scratch.
You’ll build the data path, including the program counter and CPU registers, and integrate components like the ALU (arithmetic logic unit) and main control unit.
By the end, you’ll have a working computer that can execute programs!
Throughout the course, key concepts like binary arithmetic, logic gates, the CPU, and computer memory are explained in a clear, easy-to-understand manner using simple language.
The syllabus takes you on a logical journey, gradually building your understanding of how computers function at a fundamental level.