College of Arts and Sciences

Clark Atlanta University

Department of Computing and Information Sciences

CIS 105- Structured Programming

Spring, 2004

T/TH 9:25 - 10:40

 

Instructor:  Mrs. Mia G. Moore                                  Office:  SRC RM 1024

Phone:  (404) 880 - 6943                                            E-mail: mia_moore_2000@yahoo.com

 

I.    PURPOSE

 

This introductory program design and problem-solving course provides the beginning programmer with a guide to developing structured program logic.  Flowcharts and pseudocode are used to explain programming concepts in a language-independent environment.  Java concepts are introduced.

Prerequisites:  CIS 101, CS/CIS Major.  Non-majors should enroll in CIS 103.  Students who are not Computer Science/ Computer Information Systems Majors will be withdrawn from the course.

 

II.    COURSE GOAL

 

The goal for this course is to provide students with the skills needed to successfully solve problems and design programs in a language-independent environment and to equip the student

 for successful matriculation in CIS 106.

 

III.    REQUIRED TEXTS

Robertson, Lesley A.   (2000)  Simple Program Design.  Cambridge:  Course Technology

 

Farrell, Joyce.  (2003)   Java Programming, Second Edition.  Cambridge:  Course Technology

 

IV.     COURSE STRUCTURE

1.      The course teaching method will include lecture and group discussions covering each section’s content. 

2.      Each student is required to enroll in and attend one weekly lab session and  to submit lab assignments to the Teaching Assistant on the assigned due dates. Lab times are  Mondays and Fridays, 12:00pm - 12:50pm  and 1:00pm - 1:50pm.  The lab grade will include weekly assignments, quizzes and tests.   The overall lab grade will constitute 20% of the CIS 105 grade.

 

V.  COURSE OBJECTIVES

1.                                                                  To describe the steps in the program development process

2.                                                                  To explain structured programming

3.                                                                  To introduce algorithms and pseudocode

4.                                                                  To describe program data

5.                                                                  To introduce common words and keywords used when writing pseudocode

6.                                                                  To define the three basic control structures as set out in the Structure Theorem

7.                                                                  To illustrate the three basic control structures using pseudocode

8.                                                                  To introduce methods of analyzing a problem and developing a solution

9.                                                                  To develop simple algorithms using the sequence control structure

10.                                                              To introduce methods of manually checking the developed solution

11.                                                                To elaborate on the uses of simple selection, multiple selection and nested selection in algorithms

12.                                                              To introduce the case construct in pseudocode

13.                                                              To develop algorithms using variations of the selection control structure

14.                                                              To develop algorithms which use the DOWHILE and REPEAT...UNTIL control

15.                                                              To introduce a pseudocode structure for counted repetition loops

16.                                                              To develop algorithms using variations of the repitition construct

17.                                                              To develop solution algorithms to typical programming problems using sequence, selection and repitition constructs

18.                                                              To introduce arrays and the uses of arrays

19.                                                              To develop pseudocode algorithms for common operations on arrays

20.                                                              To illustrate the manipulation of single and two-dimensional arrays

21.                                                              To introduce modularization as a means of dividing a problem into subtasks

22.                                                              To present hierarchy charts as a pictorial representation of modular program structure

23.                                                              To discuss intermodule communication, local and global variables, and the passing of parameters between modules

24.                                                              To develop programming examples that use a simple modularized structure

25.                                                              To further develop modularization using complex problems

26.                                                              To introduce cohesion as a measure of the internal strength of a module

27.                                                              To introduce coupling as a measure of the extent of information interchange between modules

28.                                                              To introduce object-orientd design

29.                                                              To define objects, classes, attributes, methods and information hiding

30.                                                              To list the steps required to create an object-oriented design to a problem

31.                                                              To introduce the concept of multiple classes, polymorphism and method overriding in object-oriented design

32.                                                              To describe the relationships between classes

33.                                                              To develop object-oriented solutions to complex problems

34.                                                              To introduce sorting algorithms:  bubble sort, insertion sort, selection sort

35.                                                              To introduce dynamic data structures:  queues, stacks, linked lists

36.                                                              To introduce object-oriented programming concepts

37.                                                              To introduce the Java programming language

38.                                                              To introduce starting a Java program

39.                                                              To introduce adding comments to a Java program

40.                                                              To introduce running a Java program

41.                                                              To introduce modifying a Java program

42.                                                              To introduce using constants and variables within a Java program

43.                                                              To introduce the int, Boolean, char and floating point data types

44.                                                              To introduce writing arithmetic statements

45.                                                              To introduce numeric type conversion

46.                                                              To introduce ASCII and Unicode

47.                                                              To introduce creating methods with no arguments, a single argument, and multiple arguments

48.                                                              To introduce creating methods that return values

49.                                                              To introduce class concepts

50.                                                              To create a class

51.                                                              To use instance methods

52.                                                              To declare objects

53.                                                              To organize classes

54.                                                              To use constructors

55.                                                              To understand blocks and scope

56.                                                              To overload a method

57.                                                              To understand ambiguity

58.                                                              To send arguments to constructors

59.                                                              To overload constructors

60.                                                              To understand the this reference

61.                                                              To work with constants

62.                                                              To use automatically imported, prewritten constants and methods

63.                                                              To use imported methods

64.                                                              To accept keyboard input

65.                                                              To draw flowcharts

66.                                                              To make decisions withg the if and if...else structures

67.                                                              To use compound statements in and if or if...else structure

68.                                                              To nest if and if...else statements

69.                                                              To use AND and OR operators

70.                                                              To use the switch statement

71.                                                              To use the conditional and NOT operators

72.                                                              To understand precedence

73.                                                              To introduce the loop structure

74.                                                              To introduce using a while loop

75.                                                              To introduce the use of shortcut arithmetic operators

76.                                                              To introduce using a for loop

77.                                                              To introduce students to how and when to use a do...while loop

78.                                                              To introduce nested loops

 

VI.      COURSE REQUIREMENTS

 

1.  Attendance:  Each student is responsible for all announcements, notes and homework whether present in class or not.  Attendance will be taken at the beginning of each class session.  It is the student’s responsibility to be counted present during roll-call.  Exceeding 3 unexcused absences, prior to midterm, will result in the student being removed from the class roster.  Exceeding 3 absences after midterm will result in the lowering of the final grade by 10 points, or one letter grade.  .

 

2.  Grading Policies:  The Final Grade will be based on an accumulation of all grades received during the semester, which will consist of :

                        Tests:                           40%

                        Midterm:                      15%

                        Final:                            15%

                        Homework:                  10%

                        Lab                              20%

                                                       ----------

                                                         100%

*Please note the University's policy  on “I” grade

 

3.  Late assignments/ makeup assignments:  There will be no makeup assignments.  This included Tests, Midterm, Final, Homework, Quizzes and Lab assignments. Late assignments will NOT be accepted.  Any exception based on extraordinary circumstances, may suffer a degradation of points awarded.

 

4.  Academic honesty:  Academic honesty is based on the principle that one’s work is one’s own.  Clark Atlanta University encourages all members of the University to accept responsibility for taking academic honesty seriously by being well-informed, by contributing to a climate in which honesty is valued, and by considering responsible ways to discourage dishonesty in the work of others.  Students, faculty, administrators and staff should not condone or tolerate cheating, plagiarism, or falsification, since such activity negatively affects members of the academic community.  Plagiarism is the presentation of all or a portion of someone else’s work as one’s own, without properly citing/documenting the work.  Plagiarism is unacceptable and will result in a failing grade in the course.

 

 

5.  Clark Atlanta University Campus Cultural Creed: 

Clark Atlanta University is committed to academic excellence, building character, and service to others.  The University will achieve its mission by cultivating an environment of honesty, kindness, mutual respect, self-discipline, school loyalty, trust, academic integrity and communal pride.  As a member of this scholarly community, I make the following pledge:

 

3.      I will work to promote academic honesty and integrity;

4.      I will work to cultivate a learning environment which opposes violence, vulgarity, lewdness and selfishness;

5.      I will embrace the concept of mutual respect by treating others the way I want them to treat me;

6.      I will support a campus culture of diversity by respecting the rights of those whose views and experiences differ from my own;

7.      I will honor and care for the sanctity of my body as the temple of God;

8.      I will commit myself to service so that I can make a difference in the world and a difference for more than just myself;

9.      I will celebrate and contribute to the “spirit of greatness” left by those who preceded me, and I will work to leave this a better place for those who follow me;

As a member of this community, I am committed to conducting myself in ways that contribute to a civil campus environment which encourages positive behavior in others.  I accept the responsibility to uphold these noble ideals as a proud member of the Clark Atlanta University Family.

1.      Course Assumptions:

1.      Reading assignments are to be completed PRIOR to the assigned class. 

2.       All course assignments (homework, lab assignments, programs, etc) should be typed

3.      Students should make 2 copies of assignments.  The first copy should be submitted, and the second copy should be used for notes and making corrections during class.

VII.    TENTATIVE CIS 105 COURSE OUTLINE

           Spring, 2004

 

1

 

01/15/03:  Course Overview

2

01/20:  Ch 1:  Program Design

            Ch 2:  Pseudocode

01/22:  Ch 3:  Developing an algorithm

3

01/27:  Test

01/29:  Ch 4:  Selection Control Structures 

4

02/03:  Ch 4: Repetition Control Structures

02/05:  Ch 6:  Pseudocode & algorithms

5

02/10:  Ch 6:  Pseudocode

02/12:  Test

6

02/17:   Ch 7:  Array Processing

 

02/19:  Ch 8:  Modularization

7

02/24:  Ch 9:  Modularization

02/26:  Test:  (Ch 7-9)

8

03/02:  Ch 11, 12 & Appendix 3:  Special Algorithms

03/04:  Midterm Exam

9

03/09:  SPRING BREAK

03/11:  SPRING BREAK

10

03/16: Ch 1:  Creating Your First Java Program

03/18:   Ch 2:  Using Data Within a Program     

11

03/23:  Java Test (Ch 1-2)

03/25:  Ch 3: Using Methods, Classes & Objects

12

03/30:  Ch 3:  Using Methods, Classes & Objects

04/01:  Test 

13

04/06:  Ch 4:  Advanced Object Concepts

04/08:  Ch 4:  Advanced Concepts

14

04/13:  Ch 5:  Input and Seclection

04/15:  Ch 6:  Looping

15

04/20: Ch 6: Looping

04/22:  Test:  (Ch 4-6)

16

04/27:  Review

04/29:  Reading Period - NO CLASS

17

05/04:  Final Exam:  4:00pm – 6:00pm

Final Exam Week