Abstract
My goal was to update the CISP 300 course to increase student interest, and retention, in the later Computer Science courses at CRC.
I successfully have implemented examples from several later CISP courses into the Spring 2014 version of CISP 310. Students are excited by these glimpses into their academic future.
Working with Los Rios and university colleagues to discover their needs for CISP 300 has been enlightening. I now have a strong relationship with the Sac State professor of record for their equivalent course CSc 10. This relationship is guiding my continuing revision of CISP 300 with the promise of articulation in the near future.
I’ll submit the revised CISP 300 Course Outline over the summer of 2014 to my department and to the Curriculum Committee. I’m waiting to get feedback from my Spring 2014 students about the course from my faculty evaluation. I’ll use this information and my experience teaching the course to decide on an appropriate Math prerequisite and if a lab component makes sense.
I developed the AS-T degree in Computer Science but have not yet submitted it to my department or to the Curriculum committee. Meeting the degree requirements involves curriculum changes to several CISP and MATH courses. That process is ongoing.
I am comfortable that I have met my goal of this sabbatical. The redesigned CISP 300 exists, and it is already benefitting CRC students.
Leave activities
My primary goal for this leave was to redevelop CISP 300 to include specific examples from later programming courses to increase student commitment to their Computer Science major.
Relation to other CISP courses
CISP 300 is meant for students who have no experience with writing computer programs. It introduces the logic concepts that underlay every computer program that has been written to date, and every one that will be written in the future on computers with von Neumann architecture.
After students complete CISP 300 they understand almost all of the logic that they will use in their later coursework. These later courses (CISP 360, 310, 400, and 430 for Computer Science majors; CISP 370 for MIS and networking majors; and CISP 401) discuss how to translate this logic into a programming language (C++ or Assembly Language or Java or Visual Basic).
I developed several assignments to give CISP 300 students a glimpse into their later programming courses. I’ve included three examples as appendices. Appendix A is a problem from CISP 310 (Assembly Language) that also ties into a student’s math coursework. Appendix B is a problem from CISP 360 (C++). Appendix C is a problem from CISP 370 (Visual Basic).
Other campuses
I solicited feedback from the Los Rios professors of the CISP courses that follow CISP 300 in the Computer Science transfer sequence. I asked them for sample problems for which students have difficulty with the logic of the solution, not the language syntax of the solution.
I learned that this was a poor question. I suspect it is like asking a Differential Equations professor what their students find difficult that should have been covered in Precalculus. There has been so much change in students who are three courses into a chain of courses linked by prerequisites that the question has little meaning.
I did not develop assignments that directly relate to the problems from CISP 400 or CISP 430 or CISP 401. The ARC, SCC, CRC professors in the programming courses were unable to explain how this logic development should fit in with CISP 400 and CISP 430. There is a concept called object-oriented programming (OOP) that is a key part of these courses. It is a reorganization of the logic from CISP 300 into classes. Upon reflection and discussions with my colleagues within Los Rios, it feels like classes are a subject for programming language courses and not a topic to include in CISP 300.
But there was a wonderful result of talking to other professors about CISP 300. I met Dr. Mary Jane Lee who teaches Computer Science at Sac State. One of her courses is CSc 10, the Sac State equivalent of CISP 300.
The summary of our conversation is in Appendix E.
AS-T Degree In Computer Science
As part of the sabbatical I researched the AS-T degree for Computer Science. The degree has three components– a Computer Science section, a Math and Physics section, and a GE section. The entire transferrable degree must be completed in 60 units.
The GE section takes 37 units of the 60 units.
The Math courses (Calculus 1 and 2, MATH 400 and 401 at CRC) and the Physics courses (PHYS 400 and 401 [check]) at CRC take 5+5+4+4 = 18 units. But 7 units of these can be double counted as part of the GE section.
So the GE, Math, and Physics courses at CRC require 37 + 18 -7 = 48 units of the 60 units.
That leaves 12 units for the Computer Science courses in the degree. These courses at CRC (which have already had C-ID numbers COMP 122, 132, 142, and 152 approved for them – we’re the only college in the district that has done this) are CISP 400, CISP 430, CISP 440, and CISP 310. The total units for these courses are 4+4+3+4 = 15 units.
Adding up the GE, Math, Physics, and Computer Science units for CRC courses that correspond to the C-ID courses in the AS-T Computer Science degree gives a total 48 + 15 = 63 units. This exceeds the 60 unit limit for the degree.
ARC and SCC are currently putting AS-T Computer Science degrees through their local Curriculum committees. Both of these degrees have the same problem - they exceed the mandated 60 unit maximum.
After this process I realized that creating the AS-T Computer Science degree is beyond the scope of this sabbatical. For CRC to meet the 60 unit maximum for the degree then the number of units in the Calculus and CISP courses will have to be reduced. Since this violates the Rule Of Five for the district course numbering, new courses will have to be created.
For this sabbatical I realized that CISP 300 is remedial to for the AS-T Computer Science degree.
Course Outline
The new Course Outline for CISP 300 is in process. I’ve included the current draft of the revised Section 4 – Learning Outcomes and Objectives in Appendix F. This is a major revision from the previous version of CISP 300. It codifies the link between CISP 300 and the later CISP courses demonstrated by the examples in Appendices A, B, and C.
Based on my conversation with Dr. Lee at Sac State I am considering putting a prerequisite of MATH 120 on CISP 300. This is the Sac State level of prerequisite. I asked Michael Lawlor, theCRC Curriculum committee chair, to help with a research project looking at how many students in the past several years have had a math course of that level or higher.
The results were surprising. Out of ~1400 students who took CISP 300 from the 2006-7 to 2012-13 school years, ~200 had completed MATH 120 or higher or assessed into this level of math course.
This has major implications for how long it takes Computer Science majors to finish their lower division coursework. These implications are in the Leave Critique section.
Lecture Only versus Lecture/Lab
After teaching CISP 300, the data from the CRC Research Office, and my discussions with Dr. Lee at Sac State, I am ambivalent about including a lab component with CISP 300. I’ve seen great benefits in my computer language courses from implementing a lab. But since CISP 300 is a paper-and-pencil course I don’t know the advantage ofhaving a weekly problem solving meeting.
I am asking my online CISP 300 students for their opinion about having a required on-campus weekly meeting as part of their Spring 2014 course evaluations.
Leave critique
I underestimated the impact that teaching three sections of CISP 300 in Spring 2014 would have on the redesign of the course.
The AS-T degree for Computer Science has two primary issues that we are discussing within my department.
The first issue involves the length of time it takes for a student to finish their transfer coursework as defined by the AS-T degree.
The AS-T degree requires MATH 400 and MATH 401. As mentioned previouslyabout 15% of CRC students in CISP 300 over the past five years had math abilities at or higher than the MATH 120 level.
Thus over that past five years most CRC students follow this path:
- CISP remedial coursework (CISP 300 and CISP 360) into their AS-T Computer Science CISP courses (CISP 400, 430, 440, 310).
- MATH remedial coursework (MATH 120, MATH 335, MATH 370) into their Calculus sequence (MATH 400, 401).
A typical CISP 300 student is on track to finish their transfer major coursework in four or more semesters (CISP 300, 360, 310 and 400, 430 and 440). This actual length of time depends on students not dropping courses and when the courses are offered. This is close to a two-year program.
But this same typical CRC studentis at least five semesters away from finishing their MATH course sequence (MATH 120, 335, 370, 400, 401). Adding in the requirement that PHYS 401 requires that MATH 400 be completed, this student is at least six semesters away from finishing the MATH and PHYS sequence in the AS-T degree. This is at least a three year program prior to transfer to university to finish their Computer Science degree.
The CIS Department is discussing what to do about this “length of time” issue. It directly impacts whether we place a MATH prerequisite on CISP 300, and the level of the MATH prerequisite. Once we reach agreement I’ll submit the modified CISP 300 Course Outline to the Curriculum Committee.
The second issue has to do with the 60 unit maximum for the AS-T in Computer Science degree.
The only way to come in at or under the 60 unit maximum is to reduce the units of several MATH and CISP courses. This unit reduction is a major undertaking. It means choosing new course numbers because it breaks one of the districtwide curriculum Rules of Five for the sharing of course numbers across the district. So, for example, if CRC decided to reduce the MATH 400 and MATH 401 courses from 5 units each to 4 units each to meet this 60 unit requirement, the new courses would need different numbers (say MATH 410 and MATH 411). These new courses would serve only students who were pursuing the AS-T degree in Computer Science at CRC.
The CIS Department is discussing what we wish to do about the AS-T degree for Computer Science given this MATH/PHYS bottleneck and the Rule of Five issues with curriculum.Once we reach department agreement I’ll submit or not submit the AS-T degree for Computer Science to the Curriculum committee.
As a result of my Spring 2014 experience with CISP 300 I am also withholding submitting a revised Course Outline until after I receive the student evaluations for this semester. My department will decide during Summer 2014 whether to trade one lecture unit for one lab unit and whether to have a math prerequisite (and if so what level of math course).
I will be happy to share the knowledge I gained during this sabbatical with any CRC faculty member.
Thank you
I would like to thank the Professional Standards committee for approving my leave request. Even with the major concerns discussed in the Leave Critique section I am excited about the future of CISP 300. Sharing the results of this sabbatical with my students, my department, and colleagues at other institutions has renewed my enthusiasm for the Computer Science transfer program.
Appendix A
CISP 300 problem that is written as a full program in CISP 310
Problem from CISP 310
Write the logic behind an Assembly Language program to calculate the greatest common divisor (GCD) of two positive integers. The GCDof two numbers is the largest integer that divides evenly into both numbers. For example the greatest common divisor of 25 and 10 is 5. The greatest common divisor of 9 and 13 is 1.
Here are the steps given to us by mathematicians that will calculate the GCD between number1 and number2:
- Make the gcd the same as number1
- Make the remainder the same as number2
- Make the dividend the same as gcd
- Make the gcd the same as remainder
- Make the remainder what is left over when dividend is divided by gcd (remember the MOD operator)
- Go back to step 3 and repeat until the remainder is 0
Create a program in pseudocode to receive input of two positive integers from the user, then perform the steps above to calculate the GCD between these two numbers, the display the GCD.
First create the program without modules. Check your answer with a handcheck table that shows the GCD is calculated correctly for inputs of 10 and 25, in that order.
Then recreate the program with a function named gcd() that has two integer value parameters and returns the GCD. Create two handcheck tables, one for main() and one for gcd(), that show the GCD is calculated correctly for inputs of 13 and 1, in that order.
Solution:
We can write the steps given in the problem with Declare and Set statements, along with some kind of loop. The problem steps involve several Integer variables: number1, number2, gcd, dividend, remainder.
//variables for problem
Declare Integer number1 = 0
Declare Integer number2 = 0
Declare Integer gcd = 0
Declare Integer dividend = 0
Declare Integer remainder = 0
//get two numbers from user
Display “This program will calculate the greatest common denominator of two”
Display “positive integers.”
Display “Enter a positive integer: “
Input number1
Display “Enter a positive integer: “
Input number2
//write the steps out in statements
//Make the gcd the same as number1
Set gcd = number1
//Make the remainder the same as number2
Set remainder = number2
//see the last step below for reason to use Do loop
Do
//Make the dividend the same as gcd
Set dividend = gcd
//Make the gcd the same as remainder
Set gcd = remainder
//Make the remainder what is left over when dividend is divided by //gcd (remember the MOD operator)
Set remainder = dividend MOD gcd
//Go back to step 3 and repeat until the remainder is 0. This is best
//done as an Do-Until loop, since the original steps didn’t check
//remainder until the end
Until ( remainder == 0 )
//after this loop, gcd holds the answer
Display number1, “ and “, number2, “ have a greatest common denominator of “, gcd
Let’s hand-check for inputs of 10 and 25 to make sure our program works.
number1 / number2 / gcd / remainder / dividend / Reason for change0 / 0 / 0 / 0 / 0 / Declare statements
10 / 25 / Input statements
10 / Set statement
25 / Set statement
10 / Set statement inside loop
25 / Set statement inside loop
10 / 10 MOD 25 = 10 (25 goes into 10 zero times with all 10 left over)
Loop back to Do
25 / Set
10 / Set
5 / 25 MOD 10 = 5 (10 goes into 25 two times with 5 left over)
Loop back to Do
10
5
0 / 10 MOD 5 = 0 (5 goes into 10 two times with 0 left over)
Exit loop since remainder == 0, final answer is gcd of 5
The calculated GCD for 10 and 25 is 5, which is the correct answer.
Now recreate this problem with a function. The new function will take the two input numbers as value parameters and return the gcd. main() will be responsible for getting the two inputs, calling gcd(), and display the returned value. We can create main() by assuming the gcd() already exists and getting its function call correct. Then we’ll create gcd().
Module main()
//variables for problem
Declare Integer number1 = 0
Declare Integer number2 = 0
Declare Integer calculatedGCD = 0// what is returned from the call to gcd()
//get two numbers from user
Display “This program will calculate the greatest common denominator of two”
Display “positive integers.”
Display “Enter a positive integer: “
Input number1
Display “Enter a positive integer: “
Input number2
//calculate the GCD with a function
calculatedGCD = gcd( number1, number2 )
//show the answer
Display number1, “ and “, number2, “ have a greatest common denominator of “ Display calculatedGCD
End Module
Now let’s do the function.
Function Integer gcd( Integer Val firstNumber, Integer Val secondNumber )
//this function needs some local variables in addition to the parameters
Declare Integer gcd = 0
Declare Integer dividend = 0
Declare Integer remainder = 0
//these steps were given to us
//initialize the gcd for loop
Set gcd = firstNumber
//initialize the remainder for loop
Set remainder = secondNumber
//see the last step below for reason to use Do loop
Do
//Make the dividend the same as gcd
Set dividend = gcd
//Make the gcd the same as remainder
Set gcd = remainder
//Make the remainder what is left over when dividend is divided by
//gcd (remember the MOD operator)
Set remainder = dividend MOD gcd
//repeat until the remainder is 0. This is best
//done as an Do-Until loop, since the original steps didn’t check
//remainder until the end
Until ( remainder == 0 )
Return gcd
End Function
Let’s hand-check for inputs of 13 and 1 to make sure our modular program works.
main()
number1 / number2 / calculatedGCD / Reason for change0 / 0 / 0 / Declare statements
13 / 1 / Input statements
call to function, gcd( 13, 1 )
1 / Set statement with function call
gcd()
firstNumber / secondNumber / gcd / remainder / dividend / Reason for change13 / 1 / Call to function, data coming from main()
0 / 0 / 0 / Declare statements
13 / Set statement
1 / Set statement
13 / Set statement inside loop
1 / Set statement inside loop
0 / 13 MOD 1 = 0 (1 goes into 13 thirteen times with zero left over)
Exit loop since remainder == 0, return 1
The calculated GCD for 13 and 1 is 1, which is correct.
Appendix B
CISP 300 problem that is written as a full program in CISP 360
Problem from CISP 360
Write a the logic behind a C++ program to accept a year between 1000 and 3000 from the keyboard as input, convert this year into an equivalent Roman numeral with the smallest number of characters, then display the original year and the Roman numeral on the monitor.
Solution: Roman numerals for years translate as M=1000, D=500, C=100, L=50, X=10, V=5, I=1.
“smallest number of characters” means use IV for 4 instead of IIII.