Introduction to Computer Science

  1. Introduction to Programming
    1. Programming Fundamentals
      1. What is Programming
        1. Problem-Solving with Code
          1. Computational Solutions
            1. Software Development Process
            2. Programming Languages Overview
              1. Language Categories
                1. Language Selection Criteria
              2. Programming Paradigms
                1. Imperative Programming
                  1. Procedural Programming
                    1. Function-Based Organization
                      1. Top-Down Design
                        1. Structured Programming
                        2. Object-Oriented Programming
                          1. Classes and Objects
                            1. Encapsulation
                              1. Inheritance
                                1. Polymorphism
                                  1. Abstraction
                                2. Declarative Programming
                                  1. Functional Programming
                                    1. Pure Functions
                                      1. Immutability
                                        1. Higher-Order Functions
                                          1. Recursion
                                          2. Logic Programming
                                            1. Rule-Based Systems
                                              1. Constraint Satisfaction
                                            2. Event-Driven Programming
                                              1. Event Handling
                                                1. User Interface Programming
                                                  1. Asynchronous Programming
                                                2. Programming Language Concepts
                                                  1. Language Levels
                                                    1. Machine Language
                                                      1. Assembly Language
                                                        1. High-Level Languages
                                                          1. Very High-Level Languages
                                                          2. Language Processing
                                                            1. Compilation Process
                                                              1. Lexical Analysis
                                                                1. Syntax Analysis
                                                                  1. Code Generation
                                                                    1. Optimization
                                                                    2. Interpretation Process
                                                                      1. Runtime Execution
                                                                        1. Just-In-Time Compilation
                                                                      2. Language Features
                                                                        1. Syntax and Grammar
                                                                          1. Semantics
                                                                            1. Type Systems
                                                                              1. Static vs Dynamic Typing
                                                                                1. Strong vs Weak Typing
                                                                                2. Memory Management
                                                                                  1. Manual Memory Management
                                                                                    1. Automatic Memory Management
                                                                                3. Basic Programming Elements
                                                                                  1. Variables and Constants
                                                                                    1. Variable Declaration
                                                                                      1. Variable Initialization
                                                                                        1. Variable Scope
                                                                                          1. Naming Conventions
                                                                                            1. Constants and Literals
                                                                                            2. Data Types
                                                                                              1. Primitive Data Types
                                                                                                1. Integer Types
                                                                                                  1. Floating-Point Types
                                                                                                    1. Boolean Type
                                                                                                      1. Character Type
                                                                                                      2. Composite Data Types
                                                                                                        1. Strings
                                                                                                          1. Arrays
                                                                                                            1. Records/Structures
                                                                                                              1. Pointers and References
                                                                                                              2. Abstract Data Types
                                                                                                                1. Lists
                                                                                                                  1. Stacks
                                                                                                                    1. Queues
                                                                                                                      1. Trees
                                                                                                                    2. Expressions and Operators
                                                                                                                      1. Arithmetic Operators
                                                                                                                        1. Relational Operators
                                                                                                                          1. Logical Operators
                                                                                                                            1. Bitwise Operators
                                                                                                                              1. Assignment Operators
                                                                                                                                1. Operator Precedence
                                                                                                                                  1. Type Conversion
                                                                                                                                  2. Input and Output
                                                                                                                                    1. Standard Input/Output
                                                                                                                                      1. File Input/Output
                                                                                                                                        1. Formatted Output
                                                                                                                                          1. Error Handling in I/O
                                                                                                                                        2. Control Structures
                                                                                                                                          1. Sequential Execution
                                                                                                                                            1. Statement Order
                                                                                                                                              1. Program Flow
                                                                                                                                              2. Selection Structures
                                                                                                                                                1. If-Then-Else Statements
                                                                                                                                                  1. Nested Conditionals
                                                                                                                                                    1. Switch-Case Statements
                                                                                                                                                      1. Conditional Expressions
                                                                                                                                                      2. Iteration Structures
                                                                                                                                                        1. For Loops
                                                                                                                                                          1. While Loops
                                                                                                                                                            1. Do-While Loops
                                                                                                                                                              1. Nested Loops
                                                                                                                                                                1. Loop Control Statements
                                                                                                                                                                  1. Break Statement
                                                                                                                                                                    1. Continue Statement
                                                                                                                                                                  2. Jump Statements
                                                                                                                                                                    1. Goto Statement
                                                                                                                                                                      1. Return Statement
                                                                                                                                                                        1. Exception Handling
                                                                                                                                                                      2. Functions and Procedures
                                                                                                                                                                        1. Function Concepts
                                                                                                                                                                          1. Function Definition
                                                                                                                                                                            1. Function Declaration
                                                                                                                                                                              1. Function Calls
                                                                                                                                                                                1. Return Values
                                                                                                                                                                                2. Parameter Passing
                                                                                                                                                                                  1. Pass by Value
                                                                                                                                                                                    1. Pass by Reference
                                                                                                                                                                                      1. Pass by Pointer
                                                                                                                                                                                        1. Default Parameters
                                                                                                                                                                                          1. Variable Arguments
                                                                                                                                                                                          2. Scope and Lifetime
                                                                                                                                                                                            1. Local Variables
                                                                                                                                                                                              1. Global Variables
                                                                                                                                                                                                1. Static Variables
                                                                                                                                                                                                  1. Variable Shadowing
                                                                                                                                                                                                  2. Recursion
                                                                                                                                                                                                    1. Recursive Function Design
                                                                                                                                                                                                      1. Base Cases
                                                                                                                                                                                                        1. Recursive Cases
                                                                                                                                                                                                          1. Stack Overflow Prevention
                                                                                                                                                                                                        2. Program Structure and Organization
                                                                                                                                                                                                          1. Modular Programming
                                                                                                                                                                                                            1. Function Decomposition
                                                                                                                                                                                                              1. Module Design
                                                                                                                                                                                                                1. Interface Design
                                                                                                                                                                                                                2. Code Documentation
                                                                                                                                                                                                                  1. Comments and Documentation
                                                                                                                                                                                                                    1. Code Readability
                                                                                                                                                                                                                      1. Documentation Standards
                                                                                                                                                                                                                      2. Error Handling
                                                                                                                                                                                                                        1. Error Types
                                                                                                                                                                                                                          1. Syntax Errors
                                                                                                                                                                                                                            1. Runtime Errors
                                                                                                                                                                                                                              1. Logic Errors
                                                                                                                                                                                                                              2. Debugging Techniques
                                                                                                                                                                                                                                1. Interactive Debugging
                                                                                                                                                                                                                                  1. Code Tracing
                                                                                                                                                                                                                                  2. Exception Handling
                                                                                                                                                                                                                                    1. Try-Catch Blocks
                                                                                                                                                                                                                                      1. Exception Types
                                                                                                                                                                                                                                        1. Error Recovery

                                                                                                                                                                                                                                  Previous

                                                                                                                                                                                                                                  4. Software Fundamentals

                                                                                                                                                                                                                                  Go to top

                                                                                                                                                                                                                                  Next

                                                                                                                                                                                                                                  6. Algorithms and Data Structures