Introduction to Computer Science
Class Meetings: Lecture sections in CCSB 1.0704:
Fall 2012 Syllabus
- lecture session MW 10:30-11:50 am; final exam Friday, December 14, 10:00 am - 12:45 pm
- lecture session TR 10:30-11:50 am; final exam Thursday, December 13, 10:00 am - 12:45 pm.
- lecture session TR 12:00-1:20 pm; final exam Tuesday, December 11, 1:00 - 3:45 pm.
You should be enrolled in one lab section. You must
attend the lecture section and the lab section that you are enrolled in; do
not drop in on another lab section without prior approval.
- Vladik Kreinovich,
office phone (915) 747-6951, teaches TR 12-1:20 pm section
Office hours: Tuesday 1:30-3 pm, Thursday
9:30-10:30 am, Thursday 3-4:30 pm, or by appointment,
in CCSB 3.0404.
- Luc Longpre,
firstname.lastname@example.org, office phone
(915) 747-6804, teaches MW section
Office hours: Monday through Thursday 1:30-2 pm,
or by appointment,
in CCSB 3.0420.
- Kay Roy, email@example.com, office phone
(915) 747-7941, teaches TR 10:30-11:50 am section
Office hours: Tuesday and Thursday 1-2 pm, or by appointment,
in CCSB 3.1008.
Teaching Assistants (TAs):
- Md. Abdul Kader, email firstname.lastname@example.org,
teaches TR 9-10:20 and TR 4:30-5:50 pm labs
office hours R 10:30-12:30 pm, or by appointment, room G.0512.
- Mohammad Shajib Khan, email email@example.com,
teaches MW 12-1:20 pm lab (and MW 10:30-11:50 lab for CS1420),
office hours T 1-3 pm, or by appointment, room G.0512.
- Melisa Vela, emails firstname.lastname@example.org, email@example.com,
teaches MW 12:00-1:20 pm and MW 3:00-4:20 pm labs
office hours M 11-12 in Room CCSB G.0512,
W 5-6 in Room CCSB 1.0704, or by appointment.
Course Objectives: First course for students majoring in
Computer Science. Introduction to problem solving with computers,
including representation, control structures, and software
development methods; closed laboratory and programming
assignments in a high-level language; programming environments;
social and ethical aspects of computing.
Prerequisite: MATH 1508 or MATH 1411 with a grade of C or better.
- Keicha Myers,
helps with TR 9-10:20 and MW
- Jeannette Vazquez, email firstname.lastname@example.org,
helps with MW 3-4:20 and TR 4:30-5:50 labs.
Knowledge and Abilities Required Before the Students Enter
the Course: Students entering the course are not required to
have background in Computer Science or programming. They should
be familiar with running software applications and using a
computer, and they should be familiar with topics from
Pre-Calculus including algebraic functions and proofs, and base
representations of numbers.
Level 3 Outcomes: Synthesis and Evaluation:
Level 3 outcomes are those in which the student can apply the
material in new situations. This is the highest level of mastery.
On successful completion of this course, students will be able to:
Level 2: Application and Analysis:
Level 2 outcomes are those in which the student can apply the
material in familiar situations, e.g., can work a problem of
familiar structure with minor changes in the details. Upon
successful completion of this course, students will be able to:
- use the syntax and semantics of a higher-level language to
express their solutions to programming problems, including the
correct use of:
- basic variable types such as integer, real number, character, string, 1-D array
- assignment, arithmetic, and logical operations
- basic control structures: if-then, for-loop, while-loop
Level 1: Knowledge and Comprehension:
Level 1 outcomes are those in which the student has been exposed
to the terms and concepts at a basic level and can supply basic
definitions. On successful completion of this course, students
will be able to:
use the syntax and semantics of a higher-level language to
express their solutions to programming problems, including the
correct use of:
- complex arithmetic and logical expressions
- simple I/O operations
- methods, i.e., user-defined subprograms
- classes, i.e., user-defined types
- describe computer representation of simple data types and
operations, including operations with binary numbers
- use testing and debugging strategies, including black-box
and white-box testing, test drivers, stubs and test suites, to
identify software faults
- use exceptions to handle violation of preconditions
- use teamwork roles and methods in the classroom
Textbook: Reading and laboratory assignment concepts for
the Java Programming Language will be drawn from Introduction to
Java Programming: Comprehensive Version, 9h Ed., by Y.
Daniel Liang (Prentice Hall, 2013).
You are expected to acquire a copy for your use in this course.
Photocopied textbooks are illegal and their use will not be
- describe, at a high level:
- technical aspects of computing: memory, operating system,
editors, interpreters, compilers, debuggers, virtual machine
- computing as a profession, from required knowledge and skills
to major career options
- relation between computing and society, including main
social, ethical, and legal issues
- history of computing
Software: Software used in this course will be available
on the Windows computers in the main computer lab and in the two
instructional labs on the first floor. For those who wish to use
the course software on your home computer, instructions will be
given in the labs.
Assignments: Reading and homework assignments will be
handed out or announced in class and in labs. If you miss a
class or lab session, it is your responsibility to find out what
you missed. You should expect to spend at least 10 hours/week
outside of class and lab on reading and homework.
Grading: Your semester grade will be based on a
combination of homework and lab assignments, weekly quizzes, lab
attendance, exams, and a final exam. The approximate percentages
are as follows:
Each of these is explained in more detail below.
The nominal percentage-score-to-letter-grade
conversion is as follows:
- 26% Homework and lab assignments (approximately 12-13 lab
- 10% Lab attendance and participation
- 3% Experiment participation or short research paper
(2 experiments or papers)
- 10% Quizzes (expect weekly)
- 36% Exams (3 exams)
- 15% Final exam
You must earn a C or better to continue to the next course in
- 90% or higher is an A
- 80-89% is a B
- 70-79% is a C
- 60-69% is a D
- below 60% is an F
Homework and Lab Assignments: Homework and lab assignments
are designed to allow you to practice using the concepts
presented in lecture and in your reading. Homework and lab
assignments may include written problems, tutorial exercises,
and programming problems. Assignments usually will be due at the
start of your lab session. Late homework will be accepted only in
unusual circumstances, by prior arrangement if at all possible.
Homework and lab assignments must be done individually, unless
otherwise instructed. For some lab assignments, you will be
working with a partner on pair programming assignments (see
below for more details).
Laboratory Sessions: You are required to sign up for and
attend the lab section associated with this course, meeting two
times a week for a total of 3 hours per week. Laboratory sessions
are designed to give you guidance and assistance with projects.
In a typical lab session, a Teaching Assistant will present
additional material that will help you understand the concepts
and complete your assignments successfully. They also will model
professional techniques and work habits, and you should feel free
to ask questions. Although you may discuss lab assignments in a
general way with other students, if you (or you and your partner
for team projects) need help coding or testing your programming
assignments you should consult the TA, a tutor (in the ACES lab),
or the instructor, rather than other students. Do not exchange
programs or let other students look at your code, even "just so
they can see how you did it."
Your TA will be grading lab assignments, and you should work
closely with the TA to make sure you understand the assignment
and any specific instructions clearly. Lab attendance is part
of your grade and you should make arrangements with your TA (and
your lab partner on team projects) if you must miss a lab. To
earn full credit for attendance, you must show up on time, stay
for the entire session, and work only on your assignment. You
will be working individually on lab projects most of the time,
but some assignments require that you work with a lab partner.
For those projects, your participation and cooperation with your
lab partner will be a factor in your grade.
Research Participation: During the course of the semester,
you must participate as a subject in two Computer Science
experiments or write two short (1-2 pages each) papers
describing some aspect of the research going on within the
Computer Science department. The purpose of this requirement is
to make you aware of the research going on within this department.
Detailed instructions for this requirement will be supplied in a
Quizzes: The purpose of each quiz is to ensure that you
are staying current with the weekly reading assignments and to
verify that you have mastered the major concepts of recent
lectures. Quizzes typically will be about 10-15 minutes in
length and may include material assigned for upcoming lectures
in addition to selected concepts from previous lectures.
Quizzes usually will be given at the beginning of class. There
will be no make-up on missed quizzes.
Exams: The purpose of the exams is to allow you to
demonstrate mastery of course concepts. Each exam will focus on
the material from the previous four or five weeks. Exams will
take place during the regular class session. There will be three
exams, contributing 36% to the overall course grade.
Because the exams contribute so heavily to your total grade, it
is vital that you do well on them. If you have test-taking
difficulties in general, or if you have difficulties with our
tests in particular, please come let me know as soon as possible.
Exams are planned for the following dates (subject to change):
Make-up exams will be
given only in extremely unusual circumstances. If you must miss
an exam, please meet with an instructor, BEFORE the exam if at
- Wednesday October 3 or Thursday, October 4, depending
on your class section (Week 6)
- Wednesday, November 14
(MW class section),
Tuesday, November 13 (TR 12-1:20 pm class section),
Monday, November 19 (TR 10:30-12 class section),
- Monday December 3 (MW class section),
Tuesday December 4 (TR 10:30-11:50 and TR 12-1:20 pm class sections)
Final Exam: The final exam will be comprehensive and will
count 15% toward your course grade. You must score 50% or better
on the final exam to pass this course. If you are planning to
take CS 2401 and cannot demonstrate your understanding of the
concepts and skills needed for success in CS 2401, you cannot
pass this course even if you have enough points to do so.
You must take the final exam during the time shown in the schedule
for the class section that you are formally enrolled in. Do not
simply "drop in" to the other section; there will not be a copy
of the exam for you. This is University policy. If you have a
scheduling conflict (e.g., if you are taking a final at EPCC) or
if you are scheduled for three final exams in one day, see one of
the instructors IN ADVANCE.
Standards of Conduct: You are expected to conduct yourself
in a professional and courteous manner, as prescribed by the UTEP
Standards of Conduct.
Graded work (for example, homework or exams), is to be completed
independently and should be unmistakably your own work (or, in
the case of pair work, your pair's work). You may not represent
as your own work material that is transcribed or copied from
another person, book, or any other source, such as a web page.
Professors are required to--and will--report academic dishonesty
and any other violation of the Standards of Conduct to the Dean
Disabilities: If you feel that you may have a disability
that requires accommodation, contact the Disabled Student Services
Office at 747-5184, go to Room 106E Union, or email email@example.com
Weekly Schedule: (tentative and subject to change)
Material covered in this course is cumulative, and new topics
will require the understanding and application of previous topics.
Notice that the first part of this course uses the Python
Programming Language for examples and assignments, and that a
transition to the Java Programming Language occurs in Week 7.
While no textbook is required for Python, you should plan ahead
to purchase and start reading your Java textbook before Week 7.
The actual content of lab assignments may vary from the example
descriptions provided below.
- Introduction to computers and Computer Science, demo of
- August 27-31 topics: computing history, main elements of
computer systems, algorithms, programming languages, introduction
to binary numbers, brief demo of JES and first Python commands:
arithmetic expressions, use of variables, assignment statements.
- Elementary Python programming/Drawing lines using while-loops
- September 3 Labor Day (no class)
- September 4-7 topics: Student practice with
arithmetic expressions, use of variables, and assignment
statements; variable tracing, simple precedence rules,
introduction to Raster images, changing color of single pixels,
drawing horizontal and vertical lines in Raster images using
while-loops, relational operators, changing slope, type
conversion, tracing loops, importance of comments and other
- Lab 1 example content: Draw house variations composed
of vertical/horizontal walls, with sloped roof.
- Drawing filled shapes with nested loops
- September 10-14 topics: Nested while-loops,
for-loop definition and advantages of comparable nested for-loop
structure, use of nested for-loops for drawing rectangular shapes,
discussion and practice with effective approaches to draw other
shapes (e.g., dependent inner loop variable), modifying code
execution rate to visually observe nested loop execution,
tracing nested loops.
- Lab 2 example content: Filled rectangular house
structure drawn with nested for-loops, experimentation to find
easy ways to draw other shapes to complete the figure.
- Defining functions with parameters to draw horizontal,
vertical, and sloped lines
- September 17-21 topics: benefits of function use for
modularization, definition of a function to draw horizontal line
with parameters (starting/ending coordinates, color, image),
computing slope with parameter values, review of while-loop,
conversion to comparable for-loop, calling functions, simple
- Lab 3 example content: Add horizontal line function
developed in lecture, and call multiple times, providing different
point coordinates and colors. Define vertical line function,
and test in a similar manner.
- Conditional statements and functional abstraction
- September 24-28 topics: logical operators, Boolean
values, conditional statement to make sure slope doesn't involve
division by 0, creation of another function which uses
conditional statements to call the appropriate line-drawing
- Lab 4 example content: Add if-statement to check for
possibility of division by 0. Define drawAnyLine to check if
single pixel, or which subordinate function should be called to
draw horizontal or vertical line.
- Test plans and debugging, defining other functions
- October 1-5 topics: black box/white box testing,
constructing a test plan with reasonable test cases, testing
programs using conditional statements, defining other functions
involving conditionals, using return statement, review for Exam 1.
- Exam 1: Wednesday 10/3 or Thursday 10/4
- Lab 5 example content: Complete test plan for lab,
test code and fix any logic problems found, construct and test
absolute value function (or max/min, boolean, or other type
- INTRODUCTION TO JAVA, drawing lines using while- and
- Reading: Chapter 2, Elementary Programming and
Chapter 4, Loops
- October 8-12 topics: Exam 1 results, Java background,
basic components and processing of Java programs, variable
declaration, basic data types, use of Dr. Java, introduction to
JRaster, drawing first line in Java using while-loop, designing
comparable for-loops, nested for-loops, using keyboard input and
simple data output displays, brief intro to GUI's and JOptionPane
- Lab 6 example content: Using both while-loops and
for-loops, draw horizontal, vertical, and sloped lines required
to construct two letters of the alphabet (initials), sized
according to user input specifications for height, and width of
- Defining Java methods to draw lines, using conditional
- Reading: Chapter 3, Selections and Chapter 5,
- October 15-19 topics: implementing problem solutions
using methods, method parameters, method invocation, defining
methods to draw horizontal/vertical/sloped lines, using if and
switch conditional statements, testing methods, method
overloading, preconditions and postconditions.
- Lab 7 example content: Part 1: Write a Java program
with content similar to Labs 3 and 4. Add Java
horizontal/sloped line method developed in lecture. Define a
Java method to draw vertical lines and a drawAnyLine method
which uses conditional statements to invoke the appropriate
line drawing method. Test with some of the original test cases.
Part 2: Write a Java program defining several small methods with
parameters, returning values of various types (numeric, boolean,
String, char) and including use of loops, conditional statements,
and basic String/Math and other predefined class methods. Invoke
and test each method, displaying returned results.
- Single-dimensional array definition, file I/O, brief intro
- Reading: Chapter 6, Single-Dimensional Arrays (also
see examples of file I/O in Chap. 14)
- October 22-26 topics: motivation for arrays through
use of input data file, brief intro to exceptions, using
while-loop to process file data.
- Lab 8 example content: Within while-loop, read input
data from file consisting of String identifier and numeric
coordinate values and pass values to method to draw line for
each set of data. Understand use of arrays to save all data.
Define second version of program defining arrays to store
different categories of data; use while-loop to store all data
from input file into arrays. Use for-loop to call line-drawing
method, passing each set of data accessed from arrays as
parameters. May include multidimensional array use (Chap. 7).
- Common array algorithms, line-specific array algorithms,
arrays passed as parameters to methods
- October 29-November 2: walk-through of array
algorithms, using loops to process arrays (e.g., determine
largest/smallest/average value), defining methods with
single-dimensional array parameters, using array return types.
- Lab 9 example content: Continue development of
Lab 8 program by defining methods to process arrays passed as
parameters. Example tasks: determine the highest point,
the average column value, whether or not points are co-linear,
whether or not points form a triangle.
- Objects and classes, object-oriented programming process
- Reading: Chapter 8, Objects and Classes and
Chapter 10, Thinking in Objects
- November 5-9 topics: software life-cycle, overview
of object-oriented programming process and design compared to
other models, teamwork models and roles in the software process,
identification of candidate classes, consideration of class
attributes and responsibilities, brief look at JRaster as
example class, major components of classes, intro to UML,
review for Exam 2.
- Exam 2: Wednesday, 11/7 or Thursday, 11/8
- Lab 10 example content: Problem analysis,
description of basic instance variables and methods required for
class GeoShape, GeoObject, or similar name, used to create
various geometric objects (e.g., dot, line, rectangle); create
JRaster2 class by adding a new constructor to JRaster. Test by
creating and manipulating objects of new class.
- Defining classes
- November 12-16 topics: Defining classes for a variety
of objects, defining application programs to create and
manipulate objects, Exam 2 results.
- Lab 11 example content: Define class for GeoShape,
GeoObject, or similar name. Construct application program to
create and manipulate objects of that class.
- Inheritance and subclasses, polymorphism, arrays of objects
- Reading: Chapter 11, Inheritance and Polymorphism
- November 19-21 topics: Inheritance principles, design
of subclasses, examination and use of PosNegGraph subclass and
its own subclass.
- November 22-23 Thanksgiving Day Holidays (no class)
- Lab 12 example content: Define class Line, a
subclass of GeoShape. Construct application program to create
and manipulate objects of both classes. Define and process
arrays of objects.
- Inheritance (cont'd.)
- November 26-30 topics: continuation of Week 13 topics,
review for Exam 3.
- Exam 3: Wednesday, 11/28 or Thursday, 11/29
- Additional exceptions and ethics in computing
- Reading: Chapter 14, Exception Handling and Text I/O
- December 3-6 topics: Handling additional exceptions
and defining exception classes, ethics in computing, Exam 3
results, review for Final Exam.
- Friday, December 7: (no class)
- Lab 13 example content: Construct application
program with multiple methods designed to produce typical
exceptions. Use try-catch-finally blocks to handle exceptions
by displaying appropriate error messages.
- Finals week:
- Final Exam for TR 12:00 lecture section:
Tuesday, December 11, 1:00 - 3:45 pm
- Final Exam for
TR 10:30 lecture section: Thursday, December
13, 10:00 am - 12:45 pm
- Final Exam for MW 10:30 lecture section:
Friday, December 14, 10:00 am - 12:45 pm