CSCS1320 C/C++ Programming ========================== Upon completion of this course, students will be able to: 1. Implement functional programs using basic syntax, including variables, loops, and conditional logic, that satisfy automated test requirements. 2. Define the relationship between a variable’s value and its memory address using basic pointer syntax (the address-of and dereference operators). 3. Recognize how data is represented and stored in memory, including the size and limits of standard primitive types. 4. Label data structures as either scalar (single-value) or composite (multi-value) based on their declaration. 5. Distinguish between collections of the same data type (arrays) and collections of differing data types (structures) within a code snippet. 6. Construct modular code by defining functions and utilizing different methods of passing data into them. 7. Select the most appropriate control structure or data type to solve a specific, predefined logical problem. 8. Utilize built-in language libraries to perform standard input/output and common computational tasks. CSCS1460 C Programming ====================== Upon completion of this course, students will be able to: 1. Implement programs using C syntax, including standard data types, arithmetic operators, and control flow structures such as loops and conditionals. 2. Determine the memory address of a variable and the value it points to using basic pointer operators. 3. Identify the memory requirements and storage limits of standard primitive data types. 4. Classify variables as scalar types or composite types based on their declaration in source code. 5. Differentiate between homogeneous data structures (arrays) and heterogeneous data structures (structs) in terms of memory layout and access. 6. Construct modular programs by defining C functions and applying parameter passing by value and by address. 7. Select the most efficient C control structure or data organization to meet a specific algorithmic requirement. 8. Utilize built-in language functions to handle standard input, output, and basic data manipulation. CSCS1730 UNIX/Linux Fundamentals ================================ Upon completion of this course, students will be able to: 1. Analyze the system hierarchy and environment variables to effectively organize and manage digital resources. 2. Evaluate system manual pages and technical documentation to independently resolve syntax challenges and discover advanced utility features. 3. Construct functional shell scripts that utilize conditional logic, iterative loops, and variables to automate repetitive tasks. 4. Synthesize the "UNIX Philosophy" by linking discrete, single-purpose utilities through input/output streams to solve complex problems. 5. Implement sophisticated pattern-matching techniques to search, filter, and transform text-based information within the command-line interface. 6. Deconstruct multifaceted technical requirements into a logical sequence of smaller, programmable steps. 7. Design reliable automation that incorporates error checking and input validation to ensure consistent execution. 8. Apply Open Source principles by producing well-documented and maintainable code that adheres to collaborative community standards. CSCS2320 Data Structures ======================== Upon successful completion of this course, students will be able to: 1. Analyze the memory allocation strategies and internal representations of primitive and user-defined data structures within system memory. 2. Implement fundamental data structures—including linked lists, stacks, queues, and trees—from first principles using pointer manipulation and dynamic memory management. 3. Evaluate the performance of alternative data structure implementations using Big O notation to determine time and space complexity. 4. Synthesize complex programs by integrating multiple data structures to solve multi-faceted computational problems. 5. Compare and contrast the trade-offs between static and dynamic memory structures regarding flexibility, overhead, and access speed. 6. Justify the selection of a specific data structure based on the unique constraints and requirements of a given algorithmic challenge. 7. Explain the practical applications of various data structures in software engineering, such as buffer management, recursion handling, and hierarchical data modeling. 8. Debug and optimize data-intensive applications by tracing memory usage and resolving issues related to data persistence and integrity. CSCS2330 Discrete Structures ============================ Upon successful completion of this course, students will be able to: 1. Simplify program control flow by applying Boolean algebraic identities to reduce the complexity of conditional logic. 2. Implement low-level data manipulations using bitwise operations to manage binary states, masks, and flags. 3. Apply recursive definitions and iterative logic to solve self-referential problems and manage hierarchical data processes. 4. Utilize modular arithmetic and number theory concepts to develop efficient algorithms for data indexing and manipulation. 5. Translate formal logical propositions into executable code to ensure rigorous validation of system constraints and user inputs. 6. Evaluate algorithmic scaling and resource consumption by applying counting principles and growth rate analysis to code structures. 7. Model discrete relationships between data elements using set theory to optimize searching, filtering, and organizational logic. 8. Verify the correctness of software modules by constructing logical models that test all possible execution paths and state transitions. CSCS2430 Digital Logic ====================== Upon successful completion of this course, students will be able to: 1. Analyze the relationship between different positional numbering systems—including binary, octal, and hexadecimal—to represent and manipulate data at the machine level. 2. Evaluate Boolean functions and logic expressions to design optimized combinational circuits that minimize gate count and propagation delay. 3. Construct complex functional units, such as adders, multiplexers, and decoders, by synthesizing fundamental logic gates (AND, OR, NOT, XOR). 4. Model sequential logic components, including flip-flops and registers, to understand how data is persisted and synchronized across clock cycles. 5. Implement finite state machines (FSMs) using digital logic components to control system behavior and manage hardware transitions. 6. Translate high-level arithmetic operations into low-level binary circuits using two’s complement and carry-lookahead logic. 7. Simulate the behavior of integrated circuits and digital systems to verify timing accuracy and logical consistency before physical deployment. 8. Design programmable logic structures that bridge the gap between raw electronic hardware and software-defined instruction sets. CSCS2460 Object-Oriented Programming using C++ ============================================== Upon successful completion of this course, students will be able to: 1. Analyze the core principles of the object-oriented paradigm, specifically encapsulation, data hiding, inheritance, and polymorphism, to manage software complexity. 2. Design modular software systems by defining custom classes that represent real-world entities and their associated behaviors. 3. Implement robust objects by developing constructors, destructors, and member functions to manage resource allocation and object lifecycle. 4. Apply operator and function overloading to create intuitive interfaces and extend the functionality of user-defined types. 5. Develop hierarchical class structures using single and multiple inheritance to promote code reusability and maintainability. 6. Utilize polymorphism and dynamic binding to create flexible, extensible code that can process diverse object types through a unified interface. 7. Leverage predefined standard libraries and container classes to solve complex computational problems efficiently. 8. Navigate and utilize a command-line environment to compile, debug, and manage multi-file software projects within a professional development workflow. CSCS2650 Computer Organization ============================== Upon successful completion of this course, students will be able to: 1. Analyze the fundamental organization of a computer system, including the functional relationships between the CPU, memory hierarchy, and I/O subsystems. 2. Evaluate the impact of various number systems and data representations on computational precision and hardware efficiency. 3. Translate high-level programming logic into assembly-level instructions to demonstrate an understanding of the underlying execution model. 4. Implement algorithmic solutions using low-level programming techniques, focusing on the effective use of processor registers and memory addressing modes. 5. Apply stack and branching logic to develop structured, modular code at the machine level. 6. Examine the interface between application software and the operating system by executing and managing direct system calls. 7. Deconstruct the role of standard runtime libraries in abstracting hardware complexities and facilitating system-level services. 8. Appraise how low-level architectural constraints and instruction set design influence the performance and optimization of high-level software. CSCS2700 Data Communications ============================ 1. Analyze the fundamental principles of network I/O and their impact on data communication efficiency and system performance. 2. Evaluate the trade-offs between various inter-process communication (IPC) mechanisms for local and distributed systems. 3. Design and implement robust application-layer protocols for reliable data exchange across heterogeneous networks. 4. Implement concurrent programming models to manage multiple simultaneous communication streams and shared resources. 5. Synthesize operating system services with application logic to facilitate seamless network integration. 6. Apply synchronization primitives to ensure data integrity and prevent race conditions in networked environments. 7. Architect scalable client-server or peer-to-peer systems using standard abstraction layers. 8. Appraise the security and reliability implications of different network communication strategies. CSCS2730 System Programming =========================== Upon successful completion of this course, students will be able to: 1. Analyze the mechanics of low-level file I/O and buffered streams to implement efficient, non-redundant data processing routines. 2. Apply Operating System APIs and system calls to manage hardware resources and mediate interactions between user-space applications and the kernel. 3. Evaluate various inter-process communication (IPC) mechanisms—including pipes, named pipes, and sockets—to determine the most effective strategy for data exchange in a distributed or local environment. 4. Construct multi-process systems by implementing process creation, execution, and synchronization logic (e.g., using fork, exec, and wait). 5. Develop robust event-driven programs capable of intercepting, handling, and managing asynchronous signals to ensure process stability. 6. Implement concurrent programming models using threads and synchronization primitives to maximize CPU utilization and manage shared resources without race conditions. 7. Synthesize complex system architectures that integrate multiple OS-level resources (file systems, networking, and task scheduling) to solve data-intensive computational problems. 8. Design collaborative software solutions that leverage modularity and resource sharing to optimize system-wide performance and scalability.