Computing and
Composition
Common
Skills,
Common Process
Fadi P. Deek and Robert S. Friedman
New Jersey Institute of Technology
Abstract
Computing and composition combine to yield a new form of
interdisciplinary
learning and intramural cooperation. A description of the analogous
processes
of problem solving and programming in an introductory computer science
course
and the writing process typically used in introductory English
composition courses
is offered. We present the writing and programming content of combined
freshman
composition and introductory computing courses that complement and
reciprocate
the goals and pedagogy employed in traditional versions of both
introductory
courses.
Instructors in all disciplines are responding to the increasing pace
and time
demands that shape our modern learning environment by investigating
and experimenting
with instructional methodologies and technologies. The intention is to
help
students take more control over their own learning and respond to the
demands
of students’ potential employers to demonstrate cooperative
teamwork, problem-solving
skills (Deek, 1999), and communication ability (Schlifer, 1997). At
New Jersey
Institute of Technology (NJIT), a problem-solving and
program-development process
(Deek, 1997) offers instructors from the Computer and Information
Science (CIS)
department and other disciplines a way to synthesize their learning
objectives
in the first year and beyond. This methodology is tailored to allow
students
and instructors to take into consideration the necessary tasks to be
performed,
skills that must be developed, and the expected learning outcomes in
various
disciplines. An example of this cooperation, described in this
article, has
been taking place between introductory computing and English
composition courses.
As we discuss below, each stage of this problem-solving and
program-development
process has a complement within the writing process (Flower &
Hayes, 1977).
The similarities in the processes suggest new ways for students to
transfer
skills between domains (Martin & Hearne, 1990; Salomon &
Perkins, 1987).
Students exercise critical-thinking skills while enhancing their
appreciation
for the role of clear and effective communication (Flower & Hayes,
1981)
as it applies both to computer programming and expository writing.
Analogous
Processes
The first course on programming provides an ideal opportunity to
introduce
students to problem solving (Deek, Kimmel, & McHugh, 1998). These
fundamental
skills are also crucial in the rest of the computer science
curriculum. Problem-solving
and programming activities are closely intertwined in the introductory
course
on computing taken by all first-year students at NJIT. In this course,
each
class is designed around a problem-solving experience that takes into
consideration
the programming material covered in that session. Problem-solving
heuristics
(Polya, 1945) and program development tasks are integrated and
introduced as
a series of activities requiring specific knowledge and skills that
must be
acquired and mastered by the students.
English Composition, the first course in a humanities and social
science sequence,
plays a parallel role to that of the computing course, both in context
in the
curriculum and content. A common goal of both courses, and a major
objective
of the curriculum itself, is the development of communication skills,
both oral
and written. Required of all students, English Composition is a
prerequisite
to major courses in computing and engineering degree programs. Rather
than keep
the domains distinct, the instructors of each course met before the
semester
began and throughout the term to prepare and conduct a set of
activities that
would complement each other, with one objective being the dissolution
of disciplinary
distinctions by demonstrating the common processes shared by both
domains. This
provided the opportunity for the English course to become more focused
on pragmatic
issues in students’ majors and areas of interest. By sharing
goals, the
course could also be approached from a problem-solving perspective
that would
demonstrate the need for analytic skills in English and verbal skills
in programming.
Each of the writing assignments, therefore, was derived from the work
that would
be conducted in the programming course.
A problem-solving and program-development process has been developed
to help
beginning computer science students fulfill the complex, multiple
tasks of problem
solving and programming (Deek, 1997). It consists of six stages:
- Problem Formulation,
- Solution Planning,
- Solution Design,
- Solution Translation,
- Solution Testing, and
- Solution Delivery.
After working through these stages, students will have produced a
fully documented
solution to a problem.
The problem-solving and program-development process begins with the
students
and the instructor, acting as facilitator, formulating the problem.
This requires
understanding the question as well as identifying the problem’s
facts.
Planning the solution proceeds with the development of an appropriate
strategy
based on various solution alternatives and the simplification of the
problem
into smaller subproblems that can be easily addressed. The solution
design then
begins to take shape as students organize, refine, and specify the
algorithmic
solution of the various components. The process continues with
translating the
algorithmic solution into programming language code. This is done by
mapping
the details of design into language syntax that is tested and then
executed
on the computer to produce the result. The product of these activities
is a
deliverable that documents the work performed at each stage of the
process.
In the composition world, the writing process is the basic procedure
through
which students gain skills in and understanding of the tasks necessary
to produce
effective expository prose written to respond to specific problems and
more
general issues. The process (Faigley, 1986) consists of activities
that promote
the planning, organizing, drafting, and revising of multiple versions
of an
essay based on themes or ideas generated by readings and discussion.
As in programming,
each of these four categories contains processes and subgoals. While
planning
a writing assignment, students often go through different exercises
that result
in the narrowing of initial, unformed ideas and amorphous
possibilities (Flower
& Hayes, 1980). In the terminology of the computing
problem-solving and
program-development process, students work toward understanding the
writing
problem they’ve been issued (Problem Formulation). They then
generate ideas
(Solution Planning), organize those ideas (Solution Design), draft
those ideas
in sentence and paragraph form (Solution Translation), test the
efficacy of
those ideas with others (Solution Testing), and finalize those ideas
in the
form of a coherent essay (Solution Delivery).
Brainstorming and free writing are popular techniques used in the
planning
stage, where students first discuss the specific assignments and
problems of
the programming class to help clarify and refine their conceptions of
the goals
to be reached there. Breaking down ideas into components to test
possible arrangements
of information into sections of drafts is a standard organizational
strategy
and leads to the completion of a working outline and draft. Students
go through
the analytic processes of peer review, where each member of a class or
team
reads other students’ essays to locate theses and supporting
evidence and
to test for the identifiable presence of an organizational strategy
that offers
coherence to their ideas. Students revise drafts based on their
peers’
comments and submit a final draft for a grade.
Process
Interrelationships
The tasks of problem formulation, planning, and design are
problem-solving
activities that require specific knowledge and skills that learners
need to
develop. The tasks of implementation and testing require similar
skills, but
with the added demand of understanding the syntax and semantics of
programming
languages. The problem-solving and program-development process
described earlier
is based on a review (Deek, 1997) of the work of Bloom (1956) on
cognitive processes,
Sternberg (1985) on cognitive structures, and Gagné (1985) on
cognitive
outcomes. This synthesis was further enhanced by the integration of
the various
programming tasks within the process. Bloom identifies a cognitive
framework
of six processes grouped as lower level (knowledge, comprehension, and
application)
and higher level (analysis, synthesis, and evaluation). Sternberg
presents a
component-based architecture for human thinking, which includes
knowledge acquisition,
performance, and metacognition. The knowledge acquisition component
includes
acquiring new knowledge, integrating new and existing knowledge, and
determining
what is relevant to a particular situation. The performance component
is concerned
with planning and implementing solutions. The metacognitive component
guides
thinking. Gagné describes effective learning environments and
their outcomes
and identifies verbal information, intellectual skills, cognitive
strategies,
motor skills, and attitudes as major learning goals. Next, we consider
each
stage of the process in some detail, providing a description of the
interrelationships
of computing and composition in this model.
Stage One—Problem
Formulation
Formulating the problem begins with creating a problem description
using an
inquisitive approach to facilitate problem understanding through
verbalization,
by asking and answering questions, gathering information, restating
the problem,
introducing notations, and drawing diagrams to visualize the problem
and possible
solutions. The initial problem statement is a description that
contains all
the relevant information: the goal, givens, unknowns, conditions, and
constraints.
All of this is subject to revision as problem understanding
develops.
Problem formulation requires knowledge about the domain or subject,
problem
modeling skills, and communication skills. The identification of
knowledge through
information gathering techniques and the representation of this
knowledge are
the primary requirements of this first stage in the problem-solving
and program-development
process. Problem Formulation, combined with domain knowledge, leads
students
to comprehend the problem at hand, acquire new related knowledge, and
develop
important cognitive processes (Bloom, 1956). The underlying cognitive
structures
are the processes used to acquire and integrate knowledge (Sternberg,
1985)
for subsequent planning, design, and implementation activities. The
cognitive
outcome takes the form of verbal information that confirms problem
understanding
and identification of facts essential at this stage (Gagné,
1985).
The cognitive objective of a preliminary problem description is
realized by
constructing a well-defined description through progressive refinement
and elaboration
of the given problem statement, including written description,
diagrams, mathematical
formulation, and so on. The preliminary mental model is obtained by
refining
the problem description using inquiry questions. Finally, a structured
representation
is obtained by extracting and organizing the relevant information
(goal, givens,
unknowns, conditions, constraints, resources, etc.) from the problem
description.
In both freshman composition and introductory computing, instructors
stress
the importance of students verbalizing what they have come to know,
thus confirming
to themselves and others that they understand the problem at hand and
can identify
its essential components. This process, obviously applicable to the
computing
classroom, is analogous to the brainstorming and clustering activities
that
begin the composition process. Here, students consider not only the
writing
problem that has been set out but also as many contextual and
tangentially related
items of information as possible. The products of these cognitive
activities
are sets of words that are investigated for potential inclusion as
either thematic
cores or informational subsets (Lunsford, 1985).
Stage Two—Solution
Planning
Planning the solution begins by developing a solution strategy,
assessing possible
alternatives, and devising a plan for solving the problem. The goal is
then
refined into subgoals that are more easily achieved, the tasks to
accomplish
each subgoal are defined, and the givens and unknowns related to the
various
problem subgoals are developed.
Solution planning requires domain knowledge, problem-specific
knowledge, and
strategic skills. Planning requires general problem-solving strategies
to discover
and assess solution alternatives and produce a plan for the problem.
The application
of knowledge, which involves problem analysis and decomposition,
or breaking
the problem into component parts (Bloom, 1956), is the key requirement
of this
stage. The most relevant cognitive structure is the performance
component that
directs the solution planning, alternative evaluation, and the problem
decomposition
process (Sternberg, 1985). An important cognitive outcome of this
stage are
the intellectual skills that demonstrate the ability to apply
knowledge (Gagné,
1985), which confirms its understanding.
Outlining the steps necessary to reach a solution is a planning
activity that
requires the ability to use problem facts, concepts, theories, or
principles
to form a solution. A solution strategy can be discovered by
identifying alternatives
using heuristics such as solving simpler, related, or analogous
problems. For
example, in solution by analogy, correspondences between the current
problem
and related, previously solved problems are exploited; the
similarities and
differences between the problems provide hints to generate alternative
strategies
for the current problem. After these solutions are evaluated, one is
selected.
In goal decomposition, the original goal is decomposed into a
collection of
intermediate subgoals, based on the strategy selected; these are then
decomposed
into sub-subgoals, and so on. Data modeling is carried out as a result
of goal
decomposition and is accomplished by organizing and associating givens
and unknowns
with each subgoal.
This stage, clearly important for the computing course, again
supports both
the general goals of the composition course, by accentuating (1) the
value of
verbal and written expression of problem analysis and (2) one of the
purposes
of pairing the disciplines—to demonstrate the parallel processes
employed
when seeking to explain and articulate a comprehensive understanding
of a programming
problem. Moreover, the cognitive skills necessary for the
problem-decomposition
process are analogous to those that support paragraph formation and
development,
as the complexities of decomposition reappear when writers select,
rearrange,
and reorder the sentences that ultimately comprise a particular
paragraph (Flower
& Hayes, 1980).
Stage
Three—Solution Design
Designing the solution entails transforming the plan into a design to
solve
the problem. First, a transformation from a high-level solution
outline to a
carefully specified solution may require further refinement. Existing
subgoals,
representing various solution components, are examined to determine
whether
additional decomposition is needed. Next, the relationships among
solution components
are established, creating a hierarchical solution organization. For
the final
implementation to take place, the subcomponents need be transformed
into modules
whose functions are specified, the data associated with these modules
are formally
represented, and an explicitly stated algorithm is created.
Solution design requires the same knowledge and skills as the
planning stage.
The major cognitive activity at the solution design stage is
synthesis,
or the reintegration of interrelated components into a coherent whole.
Student
work at this point refines and rearranges components when necessary,
establishing
a hierarchy that organizes the problem into its parts and subparts,
and producing
a new and well-organized whole as a viable solution to the problem
(Bloom, 1956).
The most relevant cognitive structure is still the performance
component, which
in addition to directing the decomposition process, is concerned with
the identification,
selection, organization, and sequencing of these tasks (Sternberg,
1985). An
important cognitive outcome of this stage is strategic skills
(Gagné,
1985) that can be demonstrated by the ability to specify the details
of solution
design. The high-level plan produced by the preceding planning stage
is refined.
This involves the sequencing of subgoals, the determination of whether
the subgoals
require further decomposition, and the establishment of hierarchical
relationships
among the various solution components. The subcomponents are now
viewed as modules
whose functions must be specified, and the data associated with these
modules
(input, output, intermediate data) are more formally represented. A
final detailed
design task transforms each subgoal into a corresponding algorithmic
specification.
This outlining and reorganization of information is practiced in both
classrooms.
The composition concerns of coherent organization and development of
ideas are
realized in a logically determined working outline. Whereas in the
computing
classroom, subgoals are translated into algorithms, in the composition
classroom,
topic sentences in paragraphs serve to guide readers toward the
specific mapping
of organizational strategies that lead readers through increasingly
credible
steps toward a conclusion. The more sophisticated the organizational
structure
and strategy, the more important the transitions bridging ideas
between paragraphs
become. Students learn how to create effective transitions that result
from
a clear understanding of the explicit and implicit relationships of
related
ideas and components. In the computing course, where a detailed
solution design
is the outcome sought for this stage, sentences that demonstrate the
design
framework are the goals in the writing classroom.
Stage Four—Solution
Translation
Translating the solution is normally carried out parallel with the
next stage
of testing. Program composition is the first step, requiring close
attention
to syntax details in order to translate design specifications into
instructions
suitable for machine execution. Comprehending existing programs is
also relevant
for solution translation and essential for reusing and integrating
existing
code. This involves understanding the code from data/control structure
and design
views, the purpose of individual instructions and subprogram
references, and
the collective function of the program as a whole. Debugging programs
is another
relevant program development task, involving considerable logical and
deductive
efforts to diagnose and correct syntax errors to ensure that the
programs will
run. In addition to the knowledge and skills of the previous stage,
solution
translation requires additional organizational, syntactical, semantic,
and pragmatic
skills. There are two major cognitive activities at the solution
translation:
synthesis and organization. Students need the ability to maintain and
access
previously generated and organized knowledge (Bloom, 1956). The
relevant cognitive
structures are the performance component, which are here concerned
with the
execution of a planned design and the memory component (Sternberg,
1985), essential
for syntactical and semantic information. Important cognitive outcomes
are the
intellectual skills required for logical or deductive ability
(Gagné,
1985) demonstrated by the diagnostic analysis of programming errors.
The composition processes run parallel to the activities of solution
translation
in computing. In composition, the cohesion of paragraphs that contain
discrete
units of information is refined to indicate the logical connection of
ideas.
This is demonstrated in rhetorical schema based in chronology, spatial
orientation,
or hierarchies of importance that help advance the reader through the
essay
by stressing the tacit and explicit transitional devises writers
employ (Vatz,
1973). In computing, this syntax-related stage is where students make
the transition
into the programming language environment. Organizational skills such
as creating
and maintaining an orderly development environment are critical. The
design
specification performed in the previous stage forms the basis for
mapping module
specifications from algorithmic logic into correct programming
language syntax—the
major objective of this stage. In addition to composing new code,
program development
also entails comprehending, reusing, and integrating existing code,
when possible.
Stage Five—Solution
Testing
Testing the solution includes verifying that the solution
specification and
results are consistent with the problem requirements. This is done by
developing
test data, testing the program using this data, and examining the
results for
accuracy. Though testing programs for correctness can take place at
various
stages of their development, a comprehensive post-translation
verification is
a must. The evaluation of test results requires not just testing for
correctness
and completeness, but also performance-oriented criteria, such as
efficiency,
reliability, and readability. Modification to the implementation,
design, or
even planning may be required on the basis of this verification. The
ability
to modify a program, especially after deployment, depends on the
availability
of documentation as well as the program comprehension and composition
skills
of the programmer doing the modification.
Solution testing requires similar cognitive skills to the previous
stage, but
with the addition of metacognitive skills. The major cognitive
activities at
the solution testing stage are analysis and evaluation to perform
further revision
(Bloom, 1956). The relevant cognitive structure is the metacognitive
component
concerned with monitoring the thinking process and evaluating the
solution (Sternberg,
1985). An important cognitive outcome is a self-critical attitude
(Gagné,
1985), the ability to critically assess one’s own thought
processes as
well as ones’ own intellectual creations. In a software
environment, testing
entails the generation of test cases on the basis of problem
requirements and
certifying that the proposed solution satisfies the test results. Test
generation
itself is not a trivial activity. It may require considerable
creativity in
the first place to recognize an appropriate test suite even for a very
elementary
problem. It may often require careful judgment to select the most
important
cases from a possibly large domain of test cases, which may have to be
pruned.
The evaluation of the test results requires not just tests for
correctness and
completeness but also performance-oriented criteria.
Through peer reviews of descriptive essays concerning or analogous to
the activities
underway in the computing course, students are never far away from the
explicit
connections between the two classes. In a composition environment,
peer review
accomplishes many of the same goals of solution testing. The solution
being
"tested" in peer review includes the viability and
credibility of
the conclusion—whether the thesis has been supported and to what
extent.
To arrive at this point, however, students must converse with one
another so
that reader/reviewers can not only articulate whether the writer has
been generally
successful, but more importantly, explain to the writer exactly how
the essay
ideas come together, how it is organized, how effective the
developmental sentences
and transitional markers are, and how well the thesis has been
supported.
Stage Six—Solution
Delivery
Delivering the solution requires that the work produced during the
previous
stages be documented and presented in a readable and organized manner.
Documenting
programs, solution strategy, and test results is essential for both
comprehension
and modification of code. In addition to internal documentation in the
form
of comments and explanations embedded in the code describing the
approach and
techniques used in solving the problem, external documentation is also
required.
Solution delivery requires organizational and communication skills.
The cognitive
activities in problem solving and program development have been
completed by
this stage, so no further problem transformations are involved.
However, the
documentation produced during the course of previous stages has to be
organized,
presented, and possibly disseminated. The documentation of the
solution strategy,
code, and test results, which has already taken place during the
previous stages,
is now integrated. In the case of large or group projects, the results
may have
to be orally presented. Moreover, for some projects, it may be
appropriate to
disseminate the information to an appropriate community of interest, a
task
made both more feasible and more important by the Internet. And it is
here that
group presentations of computing projects again come into play in the
composition
course. In sections of introductory computing and composition,
students combine
their computer science work with their English readings through oral
presentations
that reinforce the communication components of a beginning programming
class
and also explain the analogies uncovered between composition and
computing,
even at this fundamental level.
An Example: Conversion
from Feet
to Meters and the Adoption of the Metric Standard
As an example of the ways we cross over disciplinary boundaries by
using a
problem-solving and program-development process, we describe here a
basic programming
problem—the "Unit Conversion Problem" and its relevance
to the
introduction of one rhetorical mode taught in freshman
composition—the
process analysis position essay. This problem is a typical initial
case study
posed in CIS 113, Introduction to Computer Science I. The question is
simple:
How do we develop a program to convert a measurement given in
feet to
equivalent values in yard, inches, centimeters, and
meters? In
the composition class, students are posed with a slightly different
problem:
(1) to describe the process of conversion for a computing audience and
(2) to
develop an argument for a wider audience on the efficacy and potential
of adopting
and/or mandating the use of the metric system in the United States.
The goal
is for the students to understand how the six stages of the
problem-solving
and program-development process apply to communicating in different
contexts
as they analyze and describe the conversion assignment and attempt to
persuade
their readers of their point of view.
The first stage, Problem Formulation, begins with the initial
activity of creating
a brief description, offered in the computing classroom, as a
declarative sentence:
Convert a measurement given in feet to the equivalent value of (a)
yards, (b)
inches, (c) centimeters, and (d) meters. Students proceed into the
next activity
by verbalizing the answers to three questions: What is the goal? What
are the
givens? What are the unknowns? The goal is to convert a given
measurement
into its equivalent in other measurement systems. The givens
are the
number of feet to convert (and the conversion factors). The
unknowns
are what to convert to (a–d). When students move to the third
activity,
known as information elicitation, they come to see thata subtle
rhetorical shift
is occurring, as the givens and unknowns of the
verbalization—answers to
questions in text form—take on a quantifiable dimension:
equivalent values
and variables of a–d. Also, any resources such as
relevant formulas
and descriptions of the derivation processes necessary to do the
conversions
are identified. (Derivation statements are small examples of
process
paragraphs, or how tos.)
In composition class, students learn, through the Problem Formulation
stage,
the importance of distinguishing between the indefinite articles and
pronouns
used primarily to describe qualitative values and the definite
articles and
pronouns used when describing more specific information such as
quantifiable
sums. Additionally, the Problem Formulation stage gives writing
students two
more generally applicable skills necessary for the central component
of any
expository writing assignment: the formulation of an effective thesis
(a concise
articulation of the problem at hand) and the ability to order phrases
so that
they agree with, or match, the process nature of the problem.
The second stage of the problem-solving and program-development
process is
Solution Planning. It begins with a solution strategy, which is
comparable to
problem description, but adds language descriptive of the tasks that
will be
required to obtain a value in feet that will be converted into
equivalent values
of yards, inches, centimeters, and meters, and then displayed. Goal
decomposition,
the next activity, is a stepwise refinement of the initial goal
articulated
in the first stage of Problem Formulation. For example, the result
might include:
Subgoal 1: Get measurement in feet from the user.
Subgoal 2: Convert to equivalent units.
Subgoal 3: Display results.
The final activity in Solution Planning is data organization and
description.
Students create tables where the inputs (givens) and outputs
(unknowns) are
named and described. In the case of an input such as feet, the
description is
the number of feet to convert; for outputs, the descriptions (various
units);
the origin of the data (whether the information comes from the user or
a file);
and in what subgoal the information described is actually used, either
as input
or output data.
As for design, there are three main components to solving this unit
conversion
problem, and they build on the activities performed in the earlier
stage of
planning the solution. These components are: (a) instructing the
user/getting
the input, (b) doing the conversions, and (c) displaying the results.
A second-level
decomposition depicts the detailed subgoals within these components.
In this
case, the actual conversion process can be refined further. In the
next activity,
the algorithm documenting the logic necessary to reach the answer is
composed
in pseudolanguage code. In composition, the algorithm description
serves an
important summarization function, as it requires students to reflect
on the
processes necessary to reach each of the goals mentioned above. When
students
work on the algorithmic logic, they learn the necessity of having
information
presented in an orderly fashion so that a complete, verifiable, and
accurate
solution to a problem is reached. The same applies to the composition
classroom,
where students can test verbal representations of their instructions
through
peer review and determine whether their information is presented and
structured
in such a way as to make the essay understandable.
In the composition class, there are a limited number of classes
directly related
to the final three stages of the problem-solving and
program-development process
as it is presented in the computing class—Solution Translation,
Solution
Testing, and Solution Delivery. In computer programming, students work
with
the process information they have gathered during the first three
steps and
put it into programming terminology. In composition, students develop
introductory
statements that explain the importance and relevance of developing and
accurately
describing the processes encountered during their work in the unit
conversion
case study. These same ideas, after a description of the process
itself, support
the process portion of the essay, where students articulate the value
and applicability
of examples of a process such as unit conversion to more generally
applicable
contexts, and the persuasive portions of the essay, where conclusions
are drawn
from the evidence and argumentation articulated earlier in the paper.
These
concluding paragraphs represent the culmination of the problem-solving
process
as seen through the disciplinary lens of English Composition. The
original problem
to solve was not only to present a clear description of the process by
which
the conversion is implemented but also to persuade a wider audience
that there
may or may not be value in the adoption of the metric system in the
United States.
Although the Solution Translation activities in the problem-solving
and program-development
process are somewhat different from those of composition, the goals
for both
are really similar. For the programmer, Solution Translation entails
converting
the proposed design specification into matching source code that takes
into
consideration problem requirements. For example, students will create
a program
that, once complied and executed, will instruct the user to enter a
given number
in feet; this number would then be converted into equivalent values of
yards,
inches, centimeters, and meters, and the conversion results would then
be displayed.
The program is organized based on criteria set forth in the design
stage. First,
a main function calls on the instruct-input module to get input data
from the
user. After the variable "feet" is populated with a certain
value,
the other modules are called to convert the measurement from feet to
inches,
centimeters, yards, and meters. Having produced the results of the
calculations,
another module is called on to display these values.
In the writing process (Flower & Hayes, 1980), the analogous
activity to
coding solution translation is also known as translation. But for the
writer
of prose this means the creation of sentences that reflect ideas that
have been
generated and continuously revised, sometimes automatically by the
writer, during
previous steps in the process. Such translation must also take into
account
the degree of cohesion of particular paragraphs and the essay as a
whole. Discrete
units of information—sentences and paragraphs—are refined to
indicate
the logical connection of ideas and demonstrate rhetorical schema
based in chronology,
spatial orientation, or hierarchies that help advance the reader
through the
essay by stressing the tacit and explicit transitional devises writers
employ.
Now progressing into Solution Testing, the fifth step of the
problem-solving
and program-development process, students test the design of the
program they
have written and assess the results produced using evaluative
criteria. For
example, test the program with a quantifiable domain range for
feet—that
is, any real number. After inputting a specific number of feet—1,
for example—and
running the program, students receive their four outputs: the number
of feet
converted into yards, inches, centimeters, and meters. Although their
results
can be confirmed through simple calculations done autonomously of the
computer
and individually, the purpose is to demonstrate the fundamental
processes necessary
in the programming environment. However, in the composition class, the
solution
that is being evaluated is an essay that contains more than a solution
to a
word problem that is subject to complication and confusion through
misreading
and misunderstanding. The essay assignment also asks the writer to
describe
the process of the unit conversion problem as it fits into his or her
understanding
of the process of learning programming. This is often done through
analogies
that draw on an experiential context that is larger and more general
than the
activities of the conversion project itself. And it requires a
collaborative
effort among students as they test their process drafts by students
circulating
revised versions of their essays among teams of peer reviewers with
the aim
of determining the effectiveness of the analyses under review.
The final stage of the process, Solution Delivery, asks students to
produce,
organize, present, and disseminate information. They do so in the
computing
class by submitting to the instructor a complete log of the progress
through
the problem-solving and program-development process. In the
composition class,
exemplary essays are posted on course Web sites, along with contextual
information
and instructor critiques. For large or group projects taking place
later in
the semester, the results are presented orally. In paired sections of
computing
and composition, students make their presentations to the class and to
both
instructors simultaneously. Our general intention is for students to
understand
that their computer science project work and their English reading and
writing
strengthen the communication components of a beginning programming
class by
reinforcing the role of communication in computing, even at this
fundamental
level.
Conclusion
The tasks involved in each of the six basic steps of the
problem-solving and
program-development process have complementary components in the
writing process,
as we have shown here. Computer science instructors want their
students to develop
the algorithms necessary to create useful and usable solutions and
programs.
However, they also want what English instructors want: for their
students to
understand (1) that we are collectively involved in a conversation
that produces
answers to questions that exist even after a particular
process—programming
or writing—has been completed, and (2) that the problem-solving
process
is recursive—information gained and skills obtained at any one
point in
the process may, and often must, be revisited at other points along
the way
to a solution. More generally, by coordinating the content of freshman
composition
and the programming assignments of introductory computing, students
taking these
corequisites understand that the problem solving methodology that
serves them
well in programming has a collateral benefit, and in fact a
fundamental affinity,
with the processes necessary for composing an expository essay. In
order to
increase the relevance of integration, in addition to the analogous
processes
accentuated in both courses, students read expository prose concerning
the interface
of humans and computers and the societal and personal effects of
programming
activities. Other writing assignments reflect the narrowing of the
subject matter
and draw from the activity of programming. Finally, students see that
the narrative
and descriptive writing that has been a part of the computing
classroom’s
content is an integral part of the problem-solving and
program-development process
shared by both domains.
Acknowledgments
This work was supported, in part, by the Computing and Composition
Project,
a New Jersey Institute of Technology initiative funded by the Lucent
Technologies
Foundation’s Preparing Youth for Global Skills Grant program.
References
Bloom, B. S. (Ed.). (1956). Taxonomy of educational objectives.
Handbook
I: Cognitive domain. New York: McKay.
Deek, F. P. (1997). An integrated environment for problem solving
and program
development. Unpublished Doctoral Dissertation, New Jersey
Institute of
Technology, Newark.
Deek, F. P. (1999). The Software process: A parallel approach through
problem
solving and program development. Journal of Computer Science
Education, 9(1),
43–70.
Deek, F. P., Kimmel, H., & McHugh, J. (1998). Pedagogical changes
in the
delivery of the first course in computer science: Problem solving then
programming.
Journal of Engineering Education, 87(3), 313–320.
Faigley, L. (1986). Competing theories of process: A critique and a
proposal.
College English, 48(6), 527–542.
Flower, L., & Hayes, J. (1977). Problem-solving strategies and
the writing
process. College English, 39(4), 449–461.
Flower, L., & Hayes, J. (1980). Identifying the organization of
writing
processes. In L. Gregg & E. Steinberg (Eds.), Cognitive
processes in
writing (pp. 3–30). Hillsdale, NJ: Lawrence Erlbaum,
Flower, L., & Hayes, J. (1981). A cognitive process theory of
writing,
College Composition and Communication, 32, 365–387.
Gagné, R. M. (1985). The conditions of learning (4th
ed.). New
York: Holt, Rinehart and Winston.
Lunsford, A. (1985). Cognitive studies and teaching writing. In B.
McClelland
& E. Donovan (Eds.), Perspectives on research and scholarship
in composition
(pp. 145–161). New York: Modern Language Association.
Martin, B., & Hearne, J. D. (1990). Transfer of learning and
computer programming.
Educational Technology, 30(1), 41–44.
Mayer, R. (1985). Learning in complex domains: a cognitive analysis
of computer
programming. In G. H. Bower (Ed.), Psychology of learning and
motivation
(pp. 89–130). Cambridge, MA: Academic Press.
Polya, G. (1945). How to solve it. Princeton, NJ: Princeton
University
Press.
Salomon, G., & Perkins, D. (1987). Transfer of cognitive skills
from programming:
When and how? Journal of Educational Computing Research,
3(2),
149–169.
Schlifer, R. (1997). Disciplinarily and collaboration in the sciences
and humanities.
College English, 59(4), 438–452.
Sternberg, R. J. (1985). Beyond IQ: A triarchic theory of human
intelligence.
Cambridge, MA: Cambridge University Press.
Vatz, R. E. (1973). The myth of the rhetorical situation.
Philosophy and
Rhetoric, 6, 154–161.
Contributors
Fadi Deek is an associate professor of computer and information
science and
chair of the Information Technology Program at the New Jersey
Institute of Technology
(NJIT). He has taught the introductory computer science course for the
past
15 years, and he is the recipient of five different NJIT teaching
awards and
the University’s Board of Overseer’s Public and Institute
Service
Award. His current research includes learning technologies, software
engineering,
computer science education, programming environments, and problem
solving, cognition,
and learning theory. Professor Deek also directs the Computing
Education, Cognition,
and Learning Laboratory at NJIT, an applied research laboratory
dedicated to
the improvement of K–16 education.
Robert S. Friedman is a research professor in the Information
Technology Program
at NJIT. He has taught English language, literature, and humanities
courses
for the past 10 years, and he currently teaches classes in multimedia
design,
computer ethics, and information technology. Areas of research include
interdisciplinary
education, information systems, and human–computer
interaction.
Contact
Fadi Deek and Robert S. Friedman
College of Computing Sciences
New Jersey Institute of Technology
323 M L King Blvd.
University Heights
Newark, NJ 07102
fadi@cis.njit.edu
Copyright ©
2001, ISTE (International Society for Technology in Education). All
rights reserved.
|
