CS101 Syllabus

Course Syllabus

This page outlines the syllabus for the CS101 course, including weekly topics, assignments, and exams.

Course Description

This course teaches students to think algorithmically and solve problems efficiently. This course is designed to present an introduction to computer science doctrine; an understanding of core algorithmic concepts (e.g. control structures, assignment, decision structures, mathematical/Boolean operations, etc.); an introduction to structured computer programming languages, problem classification, program development and specification; software development planning techniques; debugging techniques; an introduction to the power of development environments; and documentation of software projects. Students conduct a task analysis to solve the problem, identify relevant data, produce visual and textual step-by-step solutions, and design algorithms to solve problems and learn how to translate these algorithms into working computer programs. Experience is acquired through programming projects in a high-level programming language as well as industry-standard documentation techniques such as flowcharts, UML diagrams, use cases, data flow documents, and pseudocode.

Course Objectives

• Construct flowcharts of processes using standard program structures
• Create Problem Analysis Charts, IPO charts, structure charts, coupling diagrams, and data dictionaries of a process
• Detail how computer systems process information and differentiate between processes, programs, and procedures
• Decompose logic problems and create specifications for software solutions
• Create programs in a structured high-level language that can implement software solutions to rudimentary computer science problems (e.g. simple searching, sorting, and decision-making) using both structural and OO languages
• Construct appropriate in-program data models using constants, variables, lists, tuples, strings, and arrays (utilizing standard data types)
• Create reusable software functions
• Work independently in an IDE to develop, test, debug, and publish software
• Use core logic constructs for algorithmic problem-solving, including conditional control structures, assignments, input/output methods, assignment arithmetic operators, repetition control structures, basic file operations, user-defined functions, value and reference parameters, scope rules, and name precedence
• Demonstrate elementary skills in the development of test plans, test data, and structured software walkthroughs
• Describe the difference in order of magnitude efficiency expressions (big O notation) graphically for log2N, N, and Nx

Content Outline

• The history of computer science
  • Alan Turing and the quest for computability (Church – Turing Thesis)
  • Mathematical logic and binary number systems (Leibnitz)
  • Shannon’s information theory
  • Ada Lovelace and the first algorithm
  • Operating systems data specification in memory and the evolution of programming languages
  • Classic algorithms for searching & sorting
• Problem decomposition & specification
  • Problem acquisition and description
  • Problem classification
  • Functional decomposition diagrams
  • UML and diagramming
  • Sequential, branching, and iterative processes
  • IPO charts
  • Sequence diagrams
  • Data flow diagrams
  • The need for documentation
• Processing algorithms using computer systems
  • Core system components
  • Data representation in computer systems (the true nature of bits)
  • Processes/procedures/programs
  • The idea behind “structured” programming
  • The parts of a program
  • Inclusion
  • Data typing and specification
  • Main program structure and control
  • Re-usable components
  • Input/Output
  • Compiler directives
• Structured programming concepts
  • Conditional control structures
  • Datatypes
  • Assignments
  • Input/output methods
  • Arithmetic operators
  • Repetition control structures
  • Basic file operations
  • User-defined functions
  • Value and reference parameters
  • Scope rules
  • Name precedence
• Program development environments
  • Initiating a program
  • Selecting the correct design template
  • Entering code (useful conventions)
  • Executing code
  • Build
  • Code management capabilities
• Debugging techniques and testing
  • Using the debugger
  • Trace and walkthrough
  • Finalizing software products and applications
• Software development strategies
  • Identifying opportunities to use classic algorithms and their application
  • Scale and Scope
  • Waterfall development model for software development
  • Testing and test plans
  • Code development (chunking and top-down methods)
• Standard data types & data representation
  • Variables
  • Arrays
  • Strings
  • Structures
• Documentation and coding standards
  • Documentation methods
  • Programming clarity (readability) and commenting
  • Choosing names for variables
  • Naming procedures
  • Effective commenting best practices
  • Code modularity
• Functions and re-usability
  • Declaring functions and subroutines
  • Objects
  • Methods