Course Descriptions & Syllabi

Course Descriptions & Syllabi

Search Course IDs and descriptions for:

Find complete words only

Note: some or all of the courses in the subjects marked as "Transfer" can be used towards a transfer degree: Associate of Science and Arts or Associate of Engineering Science at DACC. Transferability for specific institutions and majors varies. Consult a counselor for this information.

Areas of Study | | MATH110 syllabus

COURSE TITLE:Computer Science

This course is an introduction to the basic techniques of numerical analysis and programming using C++ on the microcomputers. It includes discussions of computer history, algorithms, flow charts, and the structure and design of software, including debugging. Students get actual experience operating a computer and peripheral equipment. The course is designed for business and engineering students. Class meets 4 hours per week. 2 lecture hours, 2 lab hours.

MATH120 (Calculus & Analytic Geometry I, M1 900 EGR 901 MTH 901) or MATH125 (Introductory Analysis I, Calculus for Business & Sciences, M1 900) with a grade of C or better.

NOTES: This course involves a great deal of work on the student's' part and would be nearly impossible for the student to master the content without persistently working the problems. Students are expected to spend an additional 4-5 hours per week outside of class to complete all assignments. Course activities include:
  1. lectures
  2. case studies
  3. videos or invited speakers
  4. assignment discussion
The class web page is updated every week, which provides supplemental information such as announcements, lecture notes, homework assignments, and students' grades.

Course Goals:
Students are expected to apply strong critical thinking skills in terms of problem solving skills. Students are expected to be able to determine from any initial question of any of the following that apply:
  1. the meaning and importance of all given information
  2. the primary unknown for which a solution is desired
  3. all secondary unknowns that will be needed to determine the primary unknown
  4. all formulas and/or theorems that are applicable to a solution
  5. the meaning/interpretation of the solution
Course Outcomes: Upon completion of this course, students will be able to:
  • Use and write all required algebraic symbols and abbreviations.
  • Clearly relate interpretation of solutions to standard algebraic and calculus-driven application problems.
  • Clearly show work or provide clear explanation as how to setup and generate a solution for application problems.
  • Apply strong critical thinking skills in terms of problem solving.
  • Understand the Fundamental Knowledge of C++
    • Discuss the history and importance of computers and computer science.
    • State the history of computers and microcomputers.
    • Know the various input/output devices along with the characteristics of each.
    • State the basic differences between the major programming languages.
    • Discuss the similarities between all languages.
    • Know why C++ was selected as the programming language for this course.
    • To understand basic computer science Concepts.
    • To become familiar with different types of programming languages.
    • To understand a typical C++ program development environment.
    • To be able to write simple computer programs in C++.
    • To become familiar with fundamental data types.
  • Know Basic Program Design:
    • To understand basic problem solving techniques.
    • Know and be able to use standard symbols to write flow charts of numerical analysis programs.
    • State the difference between integer constants and float constants and be able to write them in C++.
    • Distinguish between other different data types.
    • Write the basic operation symbols for C++ and what they mean in algebra.
    • Write simple algebraic expressions in C++.
    • To be able to use arithmetic operators.
    • To understand the precedence of arithmetic operators.
    • Use cin input statements.
    • Use cout output statements.
    • Use comment statements.
    • State the difference between executable and non-executable statements and be able to recognize statements as being executable or non-executable.
    • Be able to use { }, return, and endl statements correctly.
    • To be able to develop algorithms through the process of top-down, stepwise refinement.
    • To be able to use the increment, decrement, assignment, and logical operators.
    • Write and run a program which involves a basic input statement, a calculation, and an output statement.
  • Write Selection Structures correctly.
    • To be able to write simple decision-making statements.
    • To be able to use the if selection structures.
    • To be able to use the if/else selection structures.
    • To be able to use the switch selection structures to choose among alternative actions.
  • Write Repetition Structures loops correctly.
    • To be able to use the while, do/while, and a program repeatedly.
    • To understand counter-controlled repetition and sentinel-controlled repetition.
    • To be able to use the break and continue program control statements.
    • Recognize the parts and parameters of a while/for loop.
    • Know the range of a while/for loop.
    • Use increment/decrement operators in a loop.
    • Use and recognize correct transferals within and out of a loop.
    • State the value of an integer variable after execution of the loop.
    • State the sequence of computer operations while in the loop.
    • State the differences between the initial, incremental, and terminal parameters.
    • Write and run numerical analysis programs based on a single while/for loop such as the Newton formula, operators and collocation polynomials, the Taylor polynomial, the least squares regression formulas, etc.
    • State similarities between a single loop and a nested loop.
    • Know the order of operations between nested loops.
    • State and recognize correct transferals of control between nested loops.
    • Write a numerical analysis program based on a nested loop such as Simpson's rule for multiple n values, determinant values, etc.
  • Use Functions.
    • To understand how to construct programs modularly from small pieces called functions.
    • To be able to create new functions.
    • To understand the mechanisms used to pass information between functions.
    • To introduce simulation techniques using random number generation.
    • To understand how the visibility of identifiers is limited to specific regions of programs.
    • To understand how to write and use functions that call themselves.
  • Write one-dimensional arrays.
    • To introduce the array data structure.
    • Know how to properly declare an array.
    • Know the definition of an array subscript.
    • Be able to use arrays as parameters.
    • Be able to use character arrays as strings.
    • Understand the use of classes with array components.
    • To understand the use of arrays to store, sort, and search lists and tables of values.
    • To understand how to declare an array, initialize an array, and refer to individual elements of an array.
    • To be able to pass arrays to functions.
    • To understand basic sorting techniques.
    • Write and execute a program using one or more one-dimensional arrays.
  • Write multi-dimensional arrays
    • Know how to properly dimension the arrays.
    • To be able to declare and manipulate multiple-subscript arrays.
    • Use different forms of input and output.
    • Use loops with arrays.
    • Write and execute a program using multi-dimensional arrays for Gauss-Jordan, Cramer's Rule, orthogonal polynomial discrete methods, or other iterative techniques.
  • Use Input and Output streams.
    • Understand and use ifstream and ofstream classes.
    • Understand and use text files.
    • Write and execute a program that makes use of one or more text files.
  • Be able to use pointers.
    • To be able to use pointers to pass arguments to functions call-by-reference.
    • To understand the close relationships among pointers, arrays, and strings.
    • To understand the use of pointers to functions.
    • To be able to declare and use arrays of strings.
  • Understand Classes and Data Abstraction.
    • To understand the software engineering concepts of encapsulation and data hiding.
    • To understand the notions of data abstraction and abstract data types (ADTs).
    • To be able to create C++ ADTs, namely classes.
    • To understand how to create, use, and destroy class objects.
    • To be able to control access to object data members and member functions.
    • To begin to appreciate the value of object orientation.
    • To be able to create and destroy objects dynamically.
    • To be able to specify const (constant) objects and const member functions.
    • To understand the purpose of friend functions and friend classes.
    • To understand how to use static data members and member functions.
    • To understand the concept of a container class.
    • To understand the notion of iterator classes that walk through the elements of container classes.
    • To understand the use of the this pointer.
  • Use Classes of Objects
    • Define Classes and state their importance.
    • State the difference between variable and object declarations and be able to write them in C++.
    • Understand the components and construction of Classes.
    • Understand and implement Class reuse.
    • Write a numerical analysis program using a Class of objects.
  • Understand File Processing.
    • To be able to create, read, write, and update files.
    • To become familiar with sequential access file processing.
    • To become familiar with random access file processing.
    • To be able to specify high-performance unformatted I/O operations.
    • To understand the differences between formatted and "raw data" file processing.
    • To build a transaction processing program with random access file processing.
  • Use the C++ libraries.
  • Discuss and illustrate the concepts of efficient programming in the numerical solutions of problems.
  • Write and run C++ programs to solve numerical problems based on theory of numerical analysis procedures

MATH110 is a 16-week course. The following list is the time spent on each topic. Students who successfully complete the course will demonstrate the following outcomes by properly finishing their regular homework, quizzes, tests and a final exam. By actually working on a computer using C++ program language, the student should be able to understand and apply the following.
  • Brief Introduction to Computers and C++ Programming (week 1)
    • Computer Organization and Input/Output Devices
    • Control and Operation of the Computer
    • Personal Computing, Distributed Computing and Client/Server Computing
    • Evolution of Operating Systems
    • Brief Introduction of Machine Languages, Assembly Languages, and High-level Languages
    • Introduction to C++ Programming and History of C and C++
    • Brief Introduction of Other High-level Languages
    • Software Development Methods
    • The Key Software Trend: Object Technology
    • Brief Introduction of Hardware Trends
    • Brief Introduction of Memory Concepts
    • Brief History of the Internet
    • Career Opportunities
  • Overview of C++ Programming (week 2)
    • Brief Introduction of Algorithms
    • Brief Introduction of Flow Charts
    • Brief Introduction of Pseudocode
    • Basics of Typical C++ Environment
    • Language Elements and Expressions
    • Executable Statements
    • Assignment Operators
    • Arithmetic Operators
    • Brief Introduction of Enter, Compile, Run a simple Program
    • First Simple Program: Printing a Line of Text
    • Second Simple Program: Adding Two Integers
    • Using the Examples to Identify the Major Program Components in C++
  • Selection Structures (week 3)
    • Abstraction, Simple Data Types, and Declarations:
      • Integer (int)
      • Floating Decimal (float)
      • Double Precision Floating Decimal (double)
      • Character (char)
      • Boolean (bool)
    • Sequence Control Structures
    • Decision Making: Equality and Relational Operators
    • Confusing Equality (= =) and Assignment (=) Operators
    • The if Selection Structure
    • The if/else Selection Structure
    • The switch Multiple-Selection Structure
  • Repetition Structures (week 4)
    • Loop Design
    • Increment and Decrement Operators;
    • Counters and Counter-Controlled Repetition
    • The while Repetition Structure
    • The do/while Repetition Structure
    • The for Repetition Structure
    • The Break and Continue Statements
    • Formulating Algorithms:
      • Optional Case Study 1 (Counter-Controlled Repetition);
    • Formulating Algorithms with Top-Down, Stepwise Refinement:
      • Optional Case Study 2 (Sentinel-Controlled Repetition);
    • Formulating Algorithms with Top-Down, Stepwise Refinement:
      • Optional Case Study 3 (Nested Control Structures);
  • Reviews (week 5)
    • Identify the Algorithmic Need for Selection or Decision
      • Choose an Appropriate Selection Structure, including Nested if Structure if needed
      • Code a Select Structure
      • Implements the Algorithm
    • Identify the Algorithmic Need for Repetition
      • Choose an Appropriate Repetition Structure, including Nested Loops if Necessary
      • Code a Repetition Structure
      • Implements the Algorithm
  • Program Design (week 6)
    • C++ Standard Library
    • Argument List Correspondence
    • Logical Operators and Expressions
    • Input Numeric and String Values into Variables
    • Write Arithmetic and String Manipulation Expressions to Process Data
    • Output the Results with Formatting
    • Summary of a Simple Structured-Programming Design, Debugging and Testing
  • Functions - Part A (week 7)
    • Introduction
    • Function Definitions and Function Prototypes
    • Stepwise Design for Functions
    • Math Library Functions
    • Header Files
    • Output Arguments
    • Random Number Generation
    • Function Syntax
    • Using Objects with Functions
    • Recursive Functions
    • Example Using Recursion: The Fibonacci Series
    • Recursion vs. Iteration
  • Functions - Part B (week 8)
    • Example: A Game of Chance and Introducing enum
    • An Example of Call-function-by-value
    • An Example of Call-function-by-reference
    • Using an Initialized Reference
    • Storage Classes
    • Functions with Empty Parameter Lists
    • Inline Functions
    • References and Reference Parameters
    • Default Arguments
    • Scope Rules and Unary Scope Resolution Operator
    • Using Overloaded Function
    • Using a Function Template
  • Arrays (week 9)
    • Introduction
    • Dimensioning and Creating
    • Declaring One-dimensional Arrays
    • Accessing and Reading
    • Examples Using Arrays
    • Passing Arrays and Individual Array Elements to Function
    • Sorting an Array with Bubble Sort
    • Linear Search of an Array
    • Binary Search of a Sorted Array
    • Multiple-Subscripted Arrays
    • Optional Case Study: Computing Mean, Median and Mode Using Arrays
  • Pointers and Strings (week 10)
    • Introduction
    • Pointer Variable Declarations and Initialization
    • Pointer Operators
    • Using the const Qualifier with Pointers
    • Calling Functions by Reference with Bubble Sort Using Ca11-by-reference
    • Pointer Expressions and Pointer Arithmetic
    • The Relationship between Pointers and Arrays
    • Arrays of Pointers
    • Function Pointers
    • Introduction to Character and String Processing
    • String Manipulation Functions of the String-handling Library
    • Optional Case Study: A Card Shuffling and Dealing Simulation
  • User-defined Classes (week 11)
    • Introduction
    • Introduction to Bits, Characters, Strings and Structures;
    • Structure Definitions and Initializing Structures
    • Control Structures
    • Using Structures with Functions;
    • Accessing Members of Structures
    • Creating a Structure, Setting its Members, and Printing the Structure
    • Class Definition and Implementation
    • Classes as Operands and Arguments
    • Class Scope and Accessing Class Members
    • Defining and Using Functions and Classes
  • Classes and Data Abstraction - Part A (week 12)
    • Simple Definition of Class Time
    • Separating Time Class Interface and Implementation
    • Implementing a User-Defined Type Time With a struct
    • Implementing a Time Abstract Data Type with a Class
    • Erroneous Attempt to Access private Members of a Class
    • Returning a Reference to a private Data Member
    • Abstract Data Type Time Implementation as a Class
    • Separating Interface from Implementation
    • Controlling Access to Members
    • Access Functions and Utility Functions
    • Accessing an Object's Data Members and Member Functions
      • Through the Object's Name
      • Through a Reference
      • Through a Pointer to the Object
  • Classes and Data Abstraction - Part B (week 13)
    • Initializing Class Objects: Constructors
    • Initializing a const Object
    • Using Default Arguments with Constructors
    • Using a Constructor with Default Arguments
    • Using Destructors
    • Demonstrating the Order in which Constructors and Destructors are Called
    • Using Data Members and Member Functions
    • Using set and get Functions
    • Assigning one Object to Another with Default Memberwise Copy
    • A Subtle Trap: Returning a Reference to a private Data Member
    • Summary on Rules for Use of Classes and Objects
  • Introduction to The Data Hierarchy and File Processing (week 14)
    • Files and Streams
    • Creating a Sequential Access File
    • File Open Mode
    • Updating Sequential Access Files
    • Reading Data from a Sequential Access ASCII text File
    • Random Access Files
    • Creating a Random Access File
    • Writing Data Randomly to a Random Access File
    • Reading Data Sequentially from a Random Access File
    • Brief Introduction to Data Structures:
      • Linked Lists
      • Stacks
      • Queues
      • Trees
  • Semester Optional Group Project or Case Study (week 15)
    • The Project List is Provided near the Midterm, a Students Only Need to Choose one problem:
    • Numerical analysis:
      • The Newton formula of interpolations
      • Least squares polynomial equations
      • Min-max polynomial approximation
      • Nonlinear algebra
      • Linear systems and programming
      • Boundary value problems
    • Elevator Simulator or A Transaction Processing Program:
      • Identifying the Classes in a Problem
      • Identifying the Class’s Behaviors
      • Identifying the Objects in the problem
      • Identifying the Object’s Attributes
      • Identifying the Operations of the Class
      • Input/Output of Objects
      • Interactions/Collaborations Among Objects
      • Programming the Classes for the Elevator Simulator or Transaction Processing Program
      • Using Composition and Dynamic Object Management in the Program the student chosen.
  • Continuations on the Project or Case Study (week 16)
    • While Finishing the Semester Project, Attention should be paid on the Basics Programming Skills:
      • Algorithms, Flow Charts and Pseudocode
      • Appropriate Program Design
      • Debugging and Testing Techniques
      • Software Reusability
      • Concepts of Efficient Programming
      • Methods Using a Good Programming Style
    • While Finishing the Semester Project, Attention should be Paid on the Features of Object-oriented Languages:
      • Declare Objects and Variables.
      • Intrinsic Data Types and Return Values
      • Pass-by-reference and Pass-by-value
      • Comments, Simple Exception Catching, and Assertions
      • Definitions within a Class, Including the Constructor Methods
      • Identify the Need for Parameters
      • Show the Scope of Variables
      • Identify the Instance Variables and Local Variables
      • Overloaded Methods


C++ How to Program, 3rd Edition, Deitel & Deitel, Prentice-Hall, 2001 Lab microcomputers
Borland C++ Compiler version 5.5

See bookstore website for current book(s) at


The student will be evaluated on the degree to which student learning outcomes are achieved. A variety of methods may be used, such as tests, quizzes, class attendance and participation, reading assignments, projects, homework, presentations, and a final exam. Students are expected to completely solve homework problems as each section is assigned. Homework grade will be assigned based on the solution procedure, results, organization, and presentation. Each solution shall be explained with all of the details and diagrams necessary for another person to review. Three major separate sources will contribute to the grade in this course: Four hourly exams are given during the semester, which are composed by solving problems selected from each chapter. These hourly exams (including quizzes and projects) determine 50% of the grade. A comprehensive final exam is given at the end of the semester, which accounts for 30% of the grade. Homework (including presentation) and/or projects account for 20% of the grade.

Determination of grade based upon all work completed is as follows:
A- 90%-100%
B- 80%-89%
C- 70%-79%
D- 60%-69%
F- <60%
Grades will be adjusted to reflect the statistical distribution of scores within the class.

  • Problem Solving with C++; The Object of Programming (7th Edition) Walter Savitch, 2008
  • Engineering Problem Solving with C++; (2nd Edition), by Delores M. Etter and Jeanine A. Ingber, 2008.
Membership in the DACC community brings both rights and responsibility. As a student at DACC, you are expected to exhibit conduct compatible with the educational mission of the College. Academic dishonesty, including but not limited to, cheating and plagiarism, is not tolerated. A DACC student is also required to abide by the acceptable use policies of copyright and peer-to-peer file sharing. It is the student’s responsibility to become familiar with and adhere to the Student Code of Conduct as contained in the DACC Student Handbook. The Student Handbook is available in the Information Office in Vermilion Hall and online at:

Any student who feels s/he may need an accommodation based on the impact of a disability should contact the Testing & Academic Services Center at 217-443-8708 (TTY 217-443-8701) or stop by Cannon Hall Room 103. Please speak with your instructor privately to discuss your specific accommodation needs in this course.

Spring 2020

Upcoming Events