CSCI 101 - Computer Science I

1. Demonstrate fundamental programming constructs:
   1. Explain the syntax and semantics of a higher level language
   2. Create a program utilizing
      1. Expressions,
      2. Assignments,
      3. I/O,
      4. Iterative and conditional control structures, and
      5. functions.
   3. Utilize an integrated development environment (IDE) to create, execute, test, and debug programs.
   4. Use the techniques of decomposition to modularize a program.
   5. Apply consistent documentation and program style standards that contribute to the readability and maintainability of software.
2. Analyze and explain the behavior of simple programs utilizing variables, expressions, assignments, I/O, control structures, functions, parameter passing, preconditions, postconditions, and invariants.
3. Explain the role of algorithms in the problem-solving including;
   1. Analyze the best, average, and worst-case behaviors of an algorithm
   2. Analyze the performances of an algorithm with various input sizes.
   3. Estimate time and space complexities for a given algorithm using Big-O notation;
   4. Implement a basic numerical algorithm and apply to a given problem.
   5. Discuss the halting problem and why it has no algorithmic solution.
   6. Investigate factors other than computational efficiency that influence the choice of algorithms.
   7. Compare multiple algorithms for a given problem.
4. Utilize fundamental data types including:
   1. Primitive types (Integers, Real Numbers, Booleans, and Characters), Pointers, Arrays, Records/Structures, Strings, Enumerations
5. Analyze machine level representation of data including:
   1. Bits, bytes, and words
   2. Numeric data representation (Binary, Hexadecimal, BCD, 1’s Complement, 2’s Complement, and Floating Point format)
   3. Non-numeric data (Characters, Images, Sounds, Video)
   4. Illustrate color models and their use in computer graphics.
   5. Conversion of numerical data from one format to another
   6. Affect of fixed-length number representations on accuracy and precision
6. Describe the components of Computer Architecture
   1. Classify the organization and functional units of the Von Neumann machine.
   2. Illustrate how high-level language patterns map to assembly/machine language, including subroutine calls.
   3. Create simple assembly language program segments.
   4. Describe the basic concepts of interrupts and I/O operations.
   5. Compare and contrast different components of the memory hierarchy and memory technology, such as SRAM, DRAM, virtual memory, and cache.
   6. Explain the impact of memory latency on execution time (Von Neumann Bottleneck)
7. Examine major objectives, functions, features, and concepts of modern operating systems.
   1. Discuss the role and purpose of operating systems
   2. Compare prevailing types of operating systems.
   3. Discuss potential threats to operating systems and appropriate security measures.
   4. Diagram the interaction of an Application Programming Interface (API) with an operating system.
   5. Illustrate how applications use computing resources managed by the operating system.
   6. Explain the need for concurrency within an operating system and common methods to implement concurrency.
   7. Illustrate the principles of memory management including virtual memory, paging, thrashing, and partitioning.
   8. Discuss features of an operating system used to provide protection and security.
   9. Diagram the physical hardware devices and the virtual devices maintained by an operating system.
8. Investigate principles of secure design.
   1. Analyze the tradeoffs associated with designing security into a product.
   2. Implement input validation in applications
   3. Discuss the security implications of relying on open design vs the secrecy of design.
   4. Explain the tradeoffs of developing a program in a typesafe language.
   5. Investigate potential errors detected from both strong-type and weak-type languages.
   6. Investigate potential vulnerabilities in provided programming code.
   7. Create programs which use defensive programming techniques, including input validation, type checking, and protection against buffer overflow.
   8. Investigate common coding errors that introduce security vulnerabilities, such as buffer overflows, integer errors, and memory leaks.
9. Assess human-computer interaction and design issues:
   1. Analyze the importance of human-centered software.
   2. Implement a simple usability test for an existing software application.
10. Discuss software development methodology including:
    1. Fundamental design concepts and principles
    2. Structured and Iterative design
    3. UML (Unified Modeling Language)
    4. Coding Standards
    5. Test-case design (Unit, Integration, System, and Acceptance Testing)
    6. Programming languages
    7. Development environments
11. Apply a variety of strategies to the testing and debugging of simple programs:
    1. Apply consistent documentation and program style standards that contribute to the readability and maintainability of software.
    2. Conduct code reviews (focused on common coding errors) on program components.
    3. Differentiate between program validation and verification.
    4. Investigate potential vulnerabilities in provided programming code.
    5. Use software tools to evaluate, test, and debug programs.
    6. Analyze the extent to which another programmer’s code meets documentation and programming style standards.
    7. Implement refactoring within given program components.

• Abstraction mechanisms
• Human-computer interaction
• Assembly level machine language
• Language translation
• BCD/1’s Complement/2’s Complement
• Memory Hierarchy
• Binary/Hexadecimal
• Operating systems
• Coding Standards
• Security
• Compilation
• Software design
• Declarations and types
• UML
• Development Environments
• Verification/Validation
• Debugging/Testing

 
Course Addendum - Syllabus (Click to expand)