Java Resources for Computer Science...

$: Java Resources for Computer Science Instructionshow.docjava.com/courses/thesis/gino/diffractionRangefinding/3d/p... · cgbland@fielding.mvsu.edu Stephen J. Hartley ... elementary$
ITiCSE ’98 14 Working Group Reports

Java Resources for Computer Science InstructionReport of the ITiCSE’98 Working Group on

Curricular Opportunities of Java Based Software Development

Joseph Bergin (co-chair)Pace University, NYC, USA

[email protected]

Thomas L. Naps (co-chair)Lawrence University, USA

[email protected]

Constance G. BlandMississippi Valley State University, USA

[email protected]

Stephen J. HartleyDrexel University, USA

[email protected]

Mark A. HollidayWestern Carolina University, USA

[email protected]

Pamela B. LawheadThe University of Mississippi, USA

[email protected]

John LewisVillanova University, USA

[email protected]

Myles F. McNallyAlma College, [email protected]

Christopher H. NevisonColgate University, [email protected]

Cheng NgLa Sierra University, USA

[email protected]

George J. PotheringCollege of Charleston, USA

[email protected]

Tommi TeräsvirtaUniversity of Helsinki, Finland

[email protected]

ABSTRACTThe goal of this working group was to collect, evaluate,and foster the development of resources to serve ascomponents of both new and revised traditional coursesthat emphasize object-oriented software developmentusing Java. These courses could, for example, integrateInternet-based distributed programming, concurrency,database programming, graphics and visualization, humaninterface design and object-oriented development. Theycould therefore also be suitable as capstone courses incomputer science. The focus of the working group was ontools and techniques, including demonstrations, projects,syllabi, and pedagogical patterns. The working groupmembers are coordinating the development of a Web site(sol.pace.edu/iticse98) devoted to sharing such tools andtechniques among educators.

1 INTRODUCTIONIn the past few years a new opportunity has arisen tointegrate a number of threads in computer science

education. The Internet, object-oriented programming,and especially Java, have made it possible to incorporate abroader range of material into one or more courseswithout necessarily sacrificing the depth to which othertopics are explored. This approach integrates at leastsoftware engineering, graphics/visualization, humaninterface design, concurrency, parallelism, networking,and database connectivity. Object-oriented mechanismsof design and programming can be an important elementof such courses also. Rich content can be presented viavisualization and animation tools. In introductorycourses, students can be exposed to these topics at a highlevel of abstraction. At a more advanced level, instructorscan bring the various threads from other courses togetherin a project/capstone course.

The main purpose of this working group was to collect,evaluate, and foster the development of resources thatmight be used in courses for which Java is the primaryprogramming language. These courses may appear at theintroductory level of the curriculum where, for years,computer science educators have debated the merits of abreadth-first approach versus a depth-first approach. Inthe former, students are exposed to many areas within thediscipline of computer science but often at the expense ofshort-changing their skills at coding algorithms. In thedepth-first approach, algorithms are studied in much moredetail, with students learning how to code algorithms in anappropriate language. However, students introduced to

______________________________________________

Copyright © 1998 by the Association for Computing Machinery, Inc.Permission to make digital or hard copies of part or all of this work forpersonal or classroom use is granted without fee provided that copies arenot made or distributed for profit or commercial advantage and thatcopies bear this notice and the full citation on the first page. Copyrightsfor components of this work owned by others than ACM must behonored. Abstracting with credit is permitted. To copy otherwise, torepublish, to post on servers, or to redistribute to lists, requires priorspecific permission and/or a fee.

mailto:[email protected]


computer science via the depth-first methodology mayhave little idea of how their ability to code algorithms fitsinto the “bigger picture” of the discipline. With theabstractions offered by a language such as Java, thebreadth-first and depth-first approaches can be combinedin a new and exciting fashion. To help studentsunderstand basic algorithmic concepts and practice theircoding skills, Java’s system-independent graphics classlibraries can be used to great advantage. Additionally,early in their studies, students can use Java to developalgorithms that manipulate powerful objects such asnetwork sockets, parallel threads of execution, graphicuser interfaces, and so on. Such development allowsstudents to hone their skills at developing algorithmswhile, at the same time, they see the role of suchalgorithms in more advanced areas of computer science.

At the advanced level, the fashion in which educatorsteach subjects such as software engineering, networking,databases, parallelism, and concurrency can bedramatically affected by using appropriate Java tools.Early in such upper level courses, the abstractions offeredby class libraries can often make students’ coding muchsimpler than it would otherwise be. By later studying theimplementation techniques of such class libraries, studentscan see clear illustrations of the importance of thealgorithms that underlie the application programs. Finally,Java offers exciting new ways to integrate a variety ofsubjects into a senior-level capstone course.

Our focus is on discussing tools and techniques, includingclass libraries, demonstrations, projects, syllabi, andpedagogical patterns. Although a number of educators areteaching courses that contain some or all of theseelements, currently there is a pressing need for thedevelopment of additional materials, projects, andcurricular patterns. The working group has gathered manyof the materials that already exist and will attempt tofoster the development of new materials by creating aWeb site to disseminate the results [1-4]1

Some disclaimers need to be made before proceedingfurther. The working group is not a Java advocacy group,nor is this paper promoting the adoption of a particularcurriculum tailored to the language. We feel that Java isa vastly over-hyped language. Wherever possible, we willattempt to point out some of the pitfalls of using Java in aparticular context as well as the advantages. This workinggroup is also not proposing to present a detailed analysisof all features of the language and their appropriatenessfor a particular curriculum. That has already been done in[1-1], [1-2], and [1-3]. Rather, our goal is to focus on thecurricular opportunities afforded by the language.

2 JAVA-BASED INTRODUCTORYCOURSES WITH AN EMPHASIS ON

1 References are grouped by section/topic, thus [1-4] means

section 1, reference 4.

USING GRAPHICS ANDVISUALIZATION RESOURCES

In introductory courses, we can use graphics as analternative output mode. This approach is used to teachstudents about the full range of introductory programmingconcepts: elementary data types and control structures tomodular and object-oriented design, recursive algorithms,and introductory data structures. Educators don't needstudents to become experts at using a sophisticatedgraphics library but they do want the students to becomeexcited and enthusiastic about what the students are doing.Graphics can often build such enthusiasm while at thesame time clarifying and reinforcing the knowledge ofprogramming language mechanisms and algorithms.

This type of programming needs a simple two-dimensional graphics library. For instance, for manyyears, instructors such as Viera Proulx [2-19] have hadstudents use a simple turtle graphics library, similar toLOGO, to produce fractals in their early programmingassignments. Students find this more interesting thangenerating the Fibonacci numbers. The goal of aprogramming assignment may be graphical output itself(draw concentric circles, produce a fractal, and so on) or itmay be a visualization to depict the actions of analgorithm (say shellsort) on data. We will refer to thisdistinction as graphics programming versus visualizationin its use of graphical output. In the former, the emphasisis on having students make calls to graphic libraryroutines to acquire practice in using various controlconstructs such as iteration and recursion. The goal of thestudent’s program is merely to produce graphics outputthat requires these control constructs. In visualization, theemphasis is on having students use pre-built visualizationtools to supplement their understanding of a non-graphicalgorithm (such as sorting) that they are programming. Inthe subsequent parts of this section, we discuss dealingwith the Java graphics model and some of the resourcesavailable for use in Java-based introductory courses.

2.1 Using Java in the Introductory CourseInstructors considering creating Java-based introductorycourses that employ graphics and visualization would bewell served to consider first a number of general issuesregarding teaching with Java. A good place to beginwould be the following three resources:

! Doug Lea in [2-12] has compiled a list of commonlyasked questions that instructors might find helpful insetting up a first course. The article is somewhatdated (1996) but the issues raised in the article arestill valid and informative. There are answers toquestions like “Do I cover all classes in the CS1course?” that will help in deciding the syllabus for theearly courses.

• Paul Tyma’s article [2-30] is filled with a discussionof features that make Java both appropriate andinappropriate as a language for teaching computerscience. For instance, the effect of operating system


idiosyncrasies on platform independence and theproblem with user interfaces are explained.

• In [2-31] Mark Allen Weiss provides a candiddiscussion of experiences in porting his datastructures course from C++ to Java. The paper isfilled with ideas for scheduling topics, sampleprogramming exercises and potential pitfalls for first-time Java teachers. The absence of explicit pointersin Java is discussed, and Weiss maintains that this isnot an issue when teaching linked lists and trees in thecourse. In fact, Weiss finds that it actually reducesstudent program errors. Java’s strengths andweaknesses are presented as well as studentevaluations of the course.

2.2 The Good & Bad of the Java GraphicsModel – How to Cope With the Bad

Java, to our knowledge, is the only language that comeswith a standardized built-in graphics library. Platformindependence of the graphics library allows instructors toshare ideas and exercises, and students to program ontheir own machines, regardless of difference from theplatform used in the school's computer lab. Java isextensible, so instructors can easily customize the lookand feel of Java programming by the creation ofcustomized classes. This is all on the positive side.

On the negative side, Java’s underlying graphics modelhas a number of problems, especially for students inintroductory courses. As noted by authors such as EricRoberts and Antoine Picard [2-19], Java suffers from:

• A device-oriented library so that graphics calls aremade relative to a pixel-based coordinate system thatis resolution dependent, with integral coordinatesbased on a non-Cartesian origin (the upper leftcorner). Such a coordinate system is difficult to use,even for experienced programmers. Introductorystudents think better in a Cartesian coordinate systemor, for some recursive work, in a turtle-based graphicssystem.

• Forgetful bitmaps, in which the contents of graphicaldisplays must be redrawn in response to events. Thisis not handled by the operating system, and must bedone by the program. The refresh of sequentialgraphic displays is difficult.

• An almost stateless graphics context, which does notkeep track of the current pen position or the positionof drawn graphic objects. Having the graphics contextmaintain as much of its internal state as possible helpsnovice programmers.

Some of these issues are addressed in the 1.2 release ofJava. However, the instability the language, and inparticular the graphics library, to remain a major concernfor any instructor. A further complication is the generalway that Java defers to the operating system in threadmanagement, and only partially defers in regard towindow management. Despite Java’s claims of full-

fledged system independence, often one can not be surehow threaded or windowed graphics programs will act ondifferent platforms.

In response to these problems with the Java graphicsmodel, a number of higher level Java graphics contextshave been created for use in introductory courses. In anumber of cases, these also simplify or hide complexitiesin the Java’s I/O, event, or applet models. Using thesemethods, students can write interesting graphics programsearly in the course. Such contexts have been developedby each of the following individuals:

• Cay Horstmann [2-7] provides classes that integratethe graphics and event models (as well as simpler I/Omethods) as part of his recent Java textbook. Anexample of this is a line drawing method that capturesmouse clicks to define the start and end points of aline, which is then drawn. Students do not need toknow the underlying details of the supporting eventmodel.

• Thomas Naps [2-17], at Lawrence University, uses aturtle-graphics library for assignments that involverecursive fractal drawing. This approach handles theproblem of the relative statelessness of the graphicscontext and the device oriented nature of the graphicsmodel.

• Eric Roberts and Antoine Picard [2-19], at StanfordUniversity, designed a library to address the threemain problems mentioned above. Their approachemploys a graphics context, which keeps track ofcurrent state, tracking the graphics objects thatcompose it. Source code for this library’s Javaclasses is available online.

• Gordon Stegink [2-26] teaches an introductory courseat Hope College that takes a totally graphics andapplet-based approach. He provides a foundationclass through which all the applets are written. Hiscourse does not concern itself with the event model atall, and the graphics and input/output are all donethrough the foundation class.

2.3 Resources for Programming andVisualization Projects

As Java is incorporated into more introductory courses,resources for graphics-oriented projects and assignmentsare increasing. Most of these are available through theWeb. In this section we list a number of such resources,divided into graphics programming (graphical output asthe primary goal of the assignment) and visualization(graphical output used to visualize an underlying datastructure of the algorithm).

2.3.1 ProgrammingAs mentioned at the end of Section 2.2, Gordon Stegink[2-26] has developed an entire introductory courseemploying applet-based graphics programmingassignments. He has a large number of projects, rangingfrom short in-class collaborative and over-night exercises


to moderate size projects. One needs to look at his Website to see the broad range of his work, but mostintroductory language concepts are covered in at least oneassignment. Examples are (i) a short assignment onBoolean conditions where students color random pointsbased on conditions (for example, color all points abovecenter red, color all points in a defined circle green, andso forth), and (ii) a project where delivery vehicles arenavigated through a grid of possibly one-way streets to aseries of delivery points.

At Alma College, Myles McNally [2-13] uses imageprocessing as a laboratory theme in his introductorycourse. Employing RGB images, his laboratories focus onusing filters to sharpen and soften images (reinforcingfiles, two-dimensional arrays), using compression toreduce file size (files, rule-length encoding), and area fillalgorithms (files, two-dimensional arrays, recursion,events).

The CS department at Helsinki, Finland has developed aWeb site (in Finnish) [2-32] that includes all of the coursematerial in HTML format: exercises, examinationquestions along with answers and comments, students'comments on the course. The course material is based onapplications, but it introduces applets at the end of thecourse. The event model is taught using visual examples.Course material from four courses is available, allowinginstructors and students to see how the course hasevolved.

F. K. H. A. Dehne has a site [2-4] rich with resources forusing visualizations to teach early concepts. This siteprovides both tools and examples for teaching almost allconcepts taught in CS2. Each chapter of a typical CS2course is presented and examples of visualizations foreach concept are available. Topics covered in this siteinclude: data structures and algorithms, OO principles andOO design, stacks, queues, linked lists, sequences, trees,priority queues. The course notes of the instructor areavailable in HTML format as well as in zip files. The sitealso contains a Java tutorial as well as class libraries and asection on documentation.

Peter Martin [2-14] discusses the features of Java that aresignificant for teaching CS to undergraduates.Experiences using Java in a first course are presented.The author used turtle graphics and algorithm animationextensively in the course and developed a package ofclasses to support the instructional units. The supporttools for the course, as well as the developed exercises,may be found at the course Web site [2-15]. This Website is not mentioned in Martin’s paper, but it is filled withexamples for teaching almost all of the introductory topicsusing the graphics and animation classes created for thecourse.

2.3.2 VisualizationJohn Stasko of Georgia Tech has written algorithmanimation packages called Tango and Samba that rununder both XWindows and MSWindows ([2-23], [2-24],

[2-25]). Recently the Samba animation package has beenported to Java. Samba allows students to constructanimations of their algorithms by writing a sequence ofanimation primitives to a text file (called an animationscript). Samba then reads the animation script andprovides a viewing environment for the animation.Unfortunately, because JSamba is an applet with no accessto local files, JSamba must use an awkward workaround toload a net surfer’s animation script into JSamba – theanimation script must be pasted into the applet’s text box.

Tom Naps of Lawrence University has developed a JavaVisualizer class ([2-16], [2-17]) that, when instantiated bya student’s Java program, creates a graphical snapshot ofthe state of a data structure that the student’s program ismanipulating. Naps’ Visualizer class is accompanied by alibrary of standard data structures (vectors, stacks, queues,trees, linked lists, graphs) that students must use whencreating visualizations with the Visualizer class. Studentsmay easily augment the methods of the Visualizer class toadd color highlights to the data structure snapshots, and,with significantly more work, they may also extend thestructure library accompanying the Visualizer class toproduce tailor-made drawings of unique data structures.

A Web site at the University of Patras [2-5] contains shortexplanations of advanced level algorithms such as Prim,Kruskal, dynamic programming, and TSP, along withapplets visualizing the algorithms. The applets alsoaccept user input, thus allowing the student to experimentwith the algorithm.

Jeliot ([2-6], [2-29]) is an algorithm visualizationenvironment that can be used over the Web. It alsosupports visual debugging since it automatically builds ananimation of pure Java code. Jeliot animates data types inthe program, thus supporting the visualization ofelementary data types as well as data structures. Inaddition, scope of the data types and complexity of theprogram can be observed. Jeliot can be used as ademonstration tool, or the students can experiment ontheir own.

Mordechai Ben-Ari [2-1], [2-2] from the WeizmanInstitute in Israel has been working with visualizingparallel algorithms. Available code includes applets fordemonstrating distributed algorithms: Byzantine Generals,Ricart-Agrawala mutual exclusion, Dijkstra-Scholtentermination and Lamport-Chandy snapshots.

A set of visualization tools has been created by theComputer Science Department at Virginia Tech [2-35] tohelp teach statistical concepts in the social sciences.These tools serve as excellent examples of the use ofapplets in teaching.

Pam Lawhead and Dawn Wilkin’s JADE project [2-11]differs from many other algorithm demonstration sites inthat it uses Java threads to simultaneously provide thealgorithm animation, an explanation of the algorithm, andthe code for each algorithm as it runs. The code view isavailable in Java, Pascal, C and pseudo code. As the


animation runs in the animation window, the appropriatecode lines are highlighted in a separate window. This sitecould serve as an introduction to data structures andalgorithms because it provides in concurrent threadsvisualization, explanation, and a view of the code.

Susan Rodger’s JAWAA [2-20] is a tool for easilygenerating animations of a user’s programs over the Web.The user’s program can be written in any programminglanguage. The user adds JAWAA commands to theprogram, generating JAWAA output in a file. An appletthen loads JAWAA and the user’s JAWAA commandsand runs the animation. JAWAA commands consist ofsimple primitives such as circles, points, lines, andrectangles, and special commands for interacting with datastructures such as array, queue, stack, tree, and graph. Forexample, one can easily illustrate the search for anelement in an array by first using one JAWAA commandto create an array filled with elements and additionalJAWAA commands to change the color of each individualcell touched along the search. JAWAA automaticallycreates the boxes for the array and the placement of theelements in the boxes.

Rodger has also created JFLAP [2-21], a tool forinteracting with several types of automata, includingconverting one type of language to another. With JFLAPone can create graphical representations of transitiondiagrams for nondeterministic finite automata (NFA),pushdown automata (PDA), one-tape Turing machinesand two-tape Turing machines. After building anautomaton, one can step through its execution on input.New features of JFLAP include converting an NFA toDFA, minimizing a DFA, converting an NFA to a regulargrammar, converting a PDA to a context-free grammar,and converting different types of grammars to a PDA. Inmost of these conversions, the user creates the newrepresentation with JFLAP providing some help. Userscan opt to display the result.

2.3.3 ToolsTools to build student exercises are in the site created byJef Poskazner [2-33]. For instance, input/output, atroubling feature of Java, is simplified by a set of printutilities found at this site. The cryptographic tools foundhere would provide the instructor with resources to createexercises that encourage students to explore thecharacteristics of numeric data types. The widget libraryavailable at this site provides students with resources forcreating graphical user interfaces. The site also containsgraphic image processors, applet/application tools,networking tools, and additional wrappers. It is a richresource for both teachers and students.

A number of layout managers created by Cary Bear areavailable at [2-34]. The site has several layout managersextending the standard AWT managers. These layoutmanagers include a number of different Grid layouts --ProportionalLayout for arranging componentsproportionally and TreeLayout to organize components in

a tree structure. The site also includes instructions forbuilding your own layout manager.

A large collection of Java classes by Brian Bush [2-3]includes data structure libraries, a Virtual RealityModeling Package, a metrics package for measuringproperties of Java source code, and a mathematicspackage for mathematical calculations. The data structurepackage is not quite as extensive as the JGL (Java GenericLibrary) [2-36], but the source code for all the packages isavailable.

In [2-22] Bernie Roehl and others teach at a relativelyadvanced level how to combine Java and VRML toachieve interactive pages with three-dimensional graphics.It is a useful resource for individuals thinking of creatingthree-dimensional visualization with VRML. The bookincludes code samples for instance complete code for aJava-based three-dimensional server. The code examplestend to be Netscape specific. Readers are expected to havegood knowledge of Java. Sections teaching basics ofVRML are also present.

Any discussion of the fashion in which Java can alterapproaches to teaching the introductory curriculum wouldbe incomplete without citing the work of Lynn Stein atMIT. She presents a novel approach to teaching computerscience and a very effective use of Java and visualizationsin her paper [2-27]. This paper argues for an update ofour current notion of computation, with a heavy emphasison introducing concurrency early in the first course. Theon-line course materials she has developed areparadigmatically different from traditional CS1 coursesand are filled with exercises and examples designed toenhance the student’s understanding of “what computationlooks like.” The Web page [2-28] for her courses basedon this approach to teaching computer science is anexcellent source of cleverly designed exercises that get thestudents involved with the concepts by using and buildingvisualizations for each concept. The spirograph exercisesare well-designed and effective efforts to teach very earlyprogramming concepts with visual tools. The site alsoprovides a set of class libraries and tools to support theexercises.

Stein’s radical departure from the traditional CS1curriculum emphasizes some themes that will continuallyreappear in the next four sections of this paper. That is,many of the features of the Java language — its built-inclass libraries, and additional class libraries that are beingdeveloped by other educators — allow us to introduce notonly new topics in the introductory curriculum but alsonew ways of looking at problem solving. Many of theseinnovations can be enhanced further by merging themwith the graphics and visualization resources we havealready described.


3 SOFTWARE ENGINEERING3.1 IntroductionThe topics of software engineering affect and underliemost other computing disciplines. The use of Java toexplore such issues is a growing phenomenon at all stagesof a computing curriculum.

A new software development paradigm is currently takingplace in software engineering. The features that definethis new paradigm based on current technologies willnecessarily foster the following developments:

• Shift from static to dynamic applications.

• The creation of reusable software components.

• The continued migration from the use of onlylocalized resources to distributed resources.

• The migration to interactive applications [3-2].

• The ability to write software once and to use theresulting code across computer systems, operatingsystems and architectures.

• The development of a language robust enough toaccommodate the paradigm shift.

Although most of these ideas are addressed in otherdevelopments, the creation of the Java language enablessoftware developers to achieve these goals using onecentral development tool.

Many software engineering courses that use Java aredescribed on the Web. Some examples include [3-15], [3-18], [3-21], and [3-19]. Schach [3-9] has converted hissoftware engineering text to specifically address someJava issues.

In the remainder of this section, we expand upon thefollowing topics related to the development of object-oriented software:

• Platform independence.

• Efficiency.

• Class design.

• Class hierarchy design.

• Exceptions.

• High-level system design techniques.

In each section, we explore various pedagogical options,and discuss ways in which Java can be used to exemplifythe concepts. Throughout, we identify and describevarious resources that may be helpful for the educator inthe pursuit of these and related topics.

3.2 Platform IndependenceCode reuse in multiple programs or applications appealsto software designers and is the dominant reason for theprosperity and longevity (measured in computer years) ofthe Java language.

If we examine the rationale behind the development ofJava, two goals are abundantly clear: Sun Microsystemsprogrammers wanted a mechanism/tool

• to offer a degree of standardization to computerprogramming and,

• that would be totally platform independent. [3-10].

3.2.1 Introductory level exerciseThe idea of platform independence is based on the abilityto write code only once and be able subsequently toexecute this code on any machine. To demonstrate thisconcept to introductory computer science students, thefollowing assignment might be useful:

• Give students several small programs using alanguage other than Java.

• Require students to execute the program using twodifferent computer systems.

• Have the students identify which programs executedon which machines.

• Give students Java code for the same problems.

• Repeat the second and third steps (JVMs should bepresent on both computer systems).

3.2.2 Intermediate ExerciseFor intermediate students, repeat the assignment abovewith modifications. For instance, given the Java code fora particular program, ask students to code and execute thesame program in another language and repeat the stepsabove. (Most students will bring this knowledge ofanother language to the classroom.)

3.2.3 Advanced ExerciseFor advanced students, a demonstration could be done toshed light on a student’s understanding of the execution ofprograms using a preemptive versus non-preemptiveoperating systems [3- 12]. That is, given a program withmultiple threads, have students execute it using a non-preemptive operating system such as a Mac and apreemptive system such as Windows 95. Have studentsexplain what accounts for the difference in the executionof the programs using the different operating systems(The program must contain one task that monopolizes thecentral processing unit).

Such demonstrations should allow students to questionwhether a platform independent language (namely Java) istruly independent of every component of the system – inthis case the operating system.

3.2.4 Reality of platform independenceJava’s claim to fame is the idea of writing code only onceand subsequently using it in any environment. The realityis that no such language currently exists. Although weacknowledge that Java has come remarkably close toproviding such an environment, these are issues and ideasthat students should recognize – starting with the need for


a JVM (Java Virtual Machine) on the machine that isexpected to execute Java code.

Another platform independence issue, which can bereadily demonstrated, revolves around the design of userinterfaces. Because Java displays user interfaces using thecharacteristics of the host machine, designers oftenobserve differences in the displayed output.

To simplify the creation of graphical user interfaces, Javadevelopers introduced a development tool called JavaBeans. Java Bean components are formalizations ofreusable components [3-12]. Sites that contain guidanceon the creation of Java graphical user interfaces include:

• Carnegie Mellon University [3-20].

• IBM [3-23].

• Inside-Java [3-8].

• Pace University [3-1].

3.3 EfficiencyJava makes use of an interpreted model and dynamicallylinked libraries across wide-area networks. Consequently,it provides an opportunity for students to examine thecorresponding efficiency issues.

Although most Java programmers complain of the slowperformance problem, Sun Microsystems programmershave slightly different ideas about the dynamic nature ofJava. According to these programmers:

Java was designed for an environment without alinking phase. Each class or interface file iscompiled separately, before a program is run. If aclass or interface is needed, the appropriate binaryfile is dynamically loaded into the Java VirtualMachine (JVM) running the program (afterappropriate verification). There is not necessarilya single program image, since any unneededclasses on a particular run won't be loaded duringthat run. On a run when a different environmentor interaction is present, those classes may beneeded and will get loaded into the JVM forexecution then. [3- 13].

One of the major features of a Java program is use ofcomponents as needed, eliminating the need to assembleprograms into a single binary image. Examining thetradeoffs of such issues should prove to be a worthwhileendeavor for more advanced software engineeringstudents.

There are predictions from compiler theoreticians thatJava will soon be viewed as more rather than less efficientthan C [3-7]. If they are correct, programmers will beable to use Java for a larger domain of problems.

3.4 Class DesignBecause classes are the core element of object-orienteddesign, students must understand how to determine theirnature and content. They must also consider carefullyhow to protect classes, and the objects they define, from

improper use. Class design addresses the essence ofmodularity, long known to be an essential element insoftware design. It also provides the overall mechanismfor encapsulation, the means by which scope is defined forall data and functionality in a software system.

Encapsulation in Java is accomplished with visibilitymodifiers, defined at four levels (default, public,protected, and private). Teaching the full spectrum ofJava encapsulation is challenging for several reasons:

• The differences between the visibilty levels are notintuitive.

• Not all visibility modifiers apply to the same set oflanguage constructs.

• The differences cannot be fully understood untilcertain other language topics, such as inheritance andpackages, are addressed.

Some aspects of encapsulation should be addressed assoon as multiple classes are used to define a program.Therefore the full encapsulation picture becomes anevolving topic, slowly explored as the prerequisite topicsare addressed. Whether this coverage extends overmultiple courses depends on the content of those courses.In any case, it is likely a good idea to return to the bigpicture of encapsulation once all pieces are in place. Adanger of the widely diverse nature of this coverage is thatthe complete picture is never formed explicitly in thestudent’s mind.

The complete effect of all visibility modifiers is found atthe appropriate points of the Java language specification[3-4]. An appendix in [3-6], a CS1 text, succinctlysummarizes the effects of the modifiers, as well asdiscussing them throughout the text. Symes [3-11]presents an example of an introductory course syllabuswith a strong emphasis on class design issues. A book,with an accompanying Web-based discussion can befound at [3-17].

3.5 Class Hierarchy DesignThe concept of inheritance is the foundation of a classhierarchy. Inheritance allows a design to proceed from aclass with general features to its subclass that providesmore specific features. The project then incorporates onlysufficient detail at each of the level of subclass where it isneeded.

The java.awt and java.io packages make extensive use ofinheritance and provide an illustration of the technique.An introductory course can thus use these packages for anearly discussion of inheritance. For example, whenlearning the java.awt package, it can be pointed out in adiscussion of the various GUI widgets such as buttons,radios, check boxes, menu items that they are varioussubclasses of panels. Thus, panel provides a generalsupport for labeling and storing values of the widgets andeach individual subclass provides the customizedinteraction with a user as required by the correspondingwidget.


In a senior software engineering course, Java provides theframework for incorporating design of the class hierarchyin a course project. As the subclass at each level isdesigned, it can be checked for the appropriate level ofdetails. When time is limited in a course, a set ofsuperclasses can be provided at the beginning and used asa foundation for students to refine at the subclass levels.Alternatively, the various levels can be handled bydifferent teams.

An example of the use of class hierarchy is a networkprogramming course at La Sierra University [3-14]. Theinstructor provides the framework of a minimally workingclient server program to afford students a quick start intothe project. During the first week of the course, studentswill already be able to examine a running project. Theirtasks in successive weeks will be to produce subclassesthat have greater capabilities and thus extend the originalproject with additional features.

3.6 ExceptionsOne of the goals in teaching software engineering is topromote the production of robust software products. Arobust product should respond to user errors and otherpotentially catastrophic situations gracefully, withoutcollapsing abruptly, but instead support the opportunity torecover from errors. A common mechanism that supportsthis paradigm is the provision for exception handling. Ifthe programming environment supports exceptions, it ispossible to specify in advance how certain groups oferrors should be handled.

Exception handling is an integral part of Java, and isimplemented as try blocks and catch statements. In Java,the placement of a catch statement (the exception handler)immediately follows the relevant try block (that is thelikely location for trouble to occur.) This placement tendsto encourage the use of exception handling since it tracksthe flow of program logic more closely than when anexception handler is developed as an afterthoughtelsewhere in the program.

The proximity of code to its exception handler leads to anatural introduction of exception handling early in anintroductory course. This is further encouraged by Java’srequired exception handling in many of its fundamentalclass libraries. For example, all input/output and networkrelated classes require the user to provide exceptionhandling before programs will compile. Consequently, itis easy to point out that exception handling is an integralpart of program design. A good tutorial on Java exceptionhandling can be found at [3-16].

In a software engineering course, it is easy to requirestudents to design and specify all exception handling thatmay arise since the language supports it readily.Moreover the language provides a feature for a method toinclude mandatory exception handling, as illustrated bythe I/O and network related classes mentioned above.

3.7 System Design TechniquesBecause much of the discipline of software engineeringrelates to the development of large software systems,object-oriented analysis and design approaches contributeto the core pedagogy. Two popular techniques foraddressing analysis and design are the Unified ModelingLanguage (UML) and patterns. Neither of thesetechniques are specific to the Java programming language,but the nature of the language works nicely with both.

UML [3-22] is the brainchild of three previouslyindependent modeling advocates: Booch, Rumbaugh, andJacobson. It has become the de facto standard of object-oriented analysis and design notation. The idea behindpatterns is that many programming situations lendthemselves to a general approach, which can be identifiedand abstracted. Software designs can then be thought ofas instances of the general patterns.

Many educators agree that the basic ideas of UML andpatterns can be introduced at the early stages, such as CS1and CS2. Certainly, detailed aspects of these topics arebest addressed in an advanced course on large-scalesoftware development.

The Rational Web site mentioned above, was founded bythe UML authors. It allows you to download a time-limited, full featured version of Rational Rose, the CASEtool developed by the UML designers to support object-oriented analysis and design. Another UML/Java editorcan be found at [3-24]. An additional introductory levelUML tool is under development at Pace University byBergin [3-1].

An important concept in many general softwareengineering texts is patterns. This topic is covered inLarman [3-5] and the Sugar project [3-19].

4 PARALLEL AND CONCURRENTCOMPUTING USING JAVA

4.1 OverviewThe goal of this section is to investigate how Java can beused as a tool for teaching networking, database, andconcurrent and parallel computing. If models for teachingthese topics in Java can be developed, this will make itpossible to teach them more effectively. Hopefully, thiswill facilitate the teaching of these topics more broadlythroughout the Computer Science curriculum.

Java has several strengths as a general purpose object-oriented language including:

• Strong typing.

• Many compiler and run-time checks.

• No explicit pointers.

• Automatic garbage collection.

• Graphics library.

Three particular strengths of Java for the topics addressedin these sections are:


• Multithreading is an integral part of the language.

• Standard libraries to facilitate networking.

• Standard libraries for accessing SQL-compatiblerelational database systems.

These particular strengths make Java an appealingplatform for several computer science subject areas. Withbuilt-in support for threads, Java allows early introductionto the use of threads and the resulting issues ofconcurrency and synchronization. With built-in supportfor networking, Java allows the students to easily developapplications that communicate over the network and tounderstand how that communication is done. With built-insupport for database connectivity, Java allows the studentto examine issues involving databases ranging fromsimple queries to a single database to complextransactions over a distributed database. On the otherhand, while Java does not explicitly support high-performance parallel computing, libraries and tools arebeing developed in Java for multiprocessors anddistributed computers.

Each of these subject areas is addressed in a followingsection. Concurrent and parallel computing are combinedin this section. Networking and database systems arecovered in sections 5 and 6 respectively. Each of thesesections first addresses how the subject area can be treatedin a course early in the computer science curriculum. Eachsection then addresses treatment of an advanced course.

4.2 Strengths and WeaknessesHaving built-in threads makes Java a natural candidate forparallel and concurrent computing. Here we consider someof the strengths and weaknesses of Java as a tool forteaching parallel and concurrent computing. In addition toadvantages of Java which have been discussed above, Javahas two particular strengths for parallel and concurrentcomputing -- built-in multithreading and a library ofnetworking classes.

However, one of the essential objectives of parallelcomputing is high performance. Consequently, there aresome disadvantages to the use of Java:

• Java is interpreted and therefore is slower thancompiled languages.

• Support for multithreading of a shared memorymultiprocessor is platform specific and is justbeginning to appear.

• Multithreading synchronization in Java is surprisinglytricky to use.

The following recent comments underscore theimportance of the last point:

Java atomic procedures and lightweight threadscan lead programmers down the road to ruin. [4-15].

The Java threads model is (somewhat loosely)based on the concepts of monitors and condition-

variables. These were developed in the early1970s (by Dijkstra, Brinch-Hansen, Hoare, andothers) as a structured way of using the moreprimitive notion of semaphores. The standardreference quoted by Sun is [4-13]. Nevertheless,monitors and condition-variables are not easy touse. The semantics are volatile and do notcompose…. [4-22].

The first two drawbacks to doing parallel computing inJava are likely to fade as just-in-time compilers becomemore effective and operating systems facilitate the use ofthreads on multiprocessors. However, the last point, thedifficulty of reliable thread programming in Java, needs tobe addressed before Java can become an effective tool forteaching parallel and concurrent programming. Indeed,work on this problem is essential to the effective use ofJava for concurrent programming. We are focusing oninvestigating tools that have been developed to solve thisproblem and how those tools might be useful for teachingpurposes.

Before we explore such tools, we briefly consider some ofthe salient issues of parallel computing in general andtheir implications for parallel computing in Java. Themost important dichotomy in parallel computing isbetween the shared memory multiprocessor and thedistributed memory, message-passing hardware andprogramming models. Many developers consider theshared memory model to be easier to program, at least forpeople initially trained for sequential programming,whereas there are limits on the scalability of the hardwarefor this model. The message-passing model calls for morework from the programmer in terms of allocatingprocesses and data to processors, but scales to very largenumbers of processors, up to several thousand. As theshared memory model is scaled up, the hardware isgenerally limited to fewer than 100 processors for SMPmachines (symmetric multiprocessors). The model mustmove to NUMA machines (non-uniform memory access),which raises some of the same issues of data distributionthat are important for distributed memory machines. Inboth models, deadlock and other synchronization issuesare very important aspects of program development.Distributed memory machines may have synchronous orasynchronous message protocols, each with its advantagesand disadvantages. In either case, there may be significantoverhead for message-passing on distributed memorymachines, although there have been efforts in the past todevelop hardware that reduces this problem (e.g. thetransputer).

The object-oriented programming model blurs some of thedistinctions between the shared memory and distributedmemory models for parallel programming. Calling anobject method is conceptually close to sending a message.Consequently, a language such as Java may provide amodel for parallel programming that is more amenable toprogrammers working from an object-orientedbackground, leaving efficiency issues for language


implementation on the underlying hardware. Some of theways in which an object-oriented approach impacts theorganization of parallel threads of execution are thefollowing:

• Calling a method is conceptually equivalent toplacing the method's arguments into a message andsending the message to the called method's object.

! The calling thread blocks and a new thread iscreated in the called method's object to executethe method's code

! An already existing thread in the method's objectis waiting to receive the message and continuesexecution when the message arrives.

! A thread in the called method's object selects oneof several queued messages to receive based onsome criterion and that thread executes themethod associated with the received message(rendezvous).

! If the calling thread does not block after sendingthe message, then we have asynchronous ratherthan synchronous behavior.

! If the calling thread's object and the calledmethod's object are on different machines, thenwe have a remote procedure call.

• A process is like an active object that has one or morethreads encapsulated inside it and has its own privatedata.

4.3 Java Tools for Parallel and ConcurrentComputing

We conclude that Java needs an API for concurrent andparallel programming to overcome the problem of low-level synchronization primitives cited above. Such anAPI should provide

• Design combinations for method invocation /message passing (channels):

asynchronous message passing

synchronous message passing

remote procedure call

rendezvous.

• One Java virtual machine executes on a shared-memory multiprocessor or in DSM (distributedshared memory) on a distributed memorymulticomputer, transparent to the programmer.

• The supporting underlying OS implements thechannels in shared memory or distributed memory,transparent to the programmer.

At this time, such a Java virtual machine does not exist.However, significant progress has already been madetoward developing an API which implements a messagepassing paradigm for Java concurrent and parallelcomputing, JCSP (Java with CSP -- CommunicatingSequential Processes). JCSP is under development at the

University of Kent, UK, under the leadership of PeterWelch. A parallel effort called JavaPP is underway at theUniversity of Twente, Netherlands, under the leadershipof Andre Bakkers and Gerald Hilderink.

The development of a library of classes which provide aCSP style of message passing provides the tools needed todo more reliable concurrent programming in Java and tobe able to teach concurrent and parallel programming inJava effectively. This model is based on the theoreticallanguage CSP [4-12]. CSP found its first majorimplementation in Occam 2, the language developed forparallel computing in conjunction with the transputer, aprocessor developed in the mid-1980s for embedded andparallel computing. The two versions of Java with CSPmentioned above provide free libraries that implementCSP-style message-passing using channels. Channels areintermediate objects between threads that will free theprogrammer from synchronization, scheduling and datatransfer constructs. Channels are easy to use and one caneasily reason about programs that use channels. Thecomposition constructs provide sequential, parallel, andalternative reading/writing on a channel. These constructscan be used to avoid deadlock and free the programmerfrom low-level synchronization and scheduling constructs,such as monitors and semaphores. This way, a Javaprogram can be well-structured and well-behaved. Thelibrary is written in 100% Java. Link drivers forconnections over the Internet have been developed, sochannels can be used to communicate between processeson different machines. Information and the free librariesfor the two versions of Java with CSP can be found at theURLs [4-1], [4-4] [4-11].

We have tested the software from the University of Kent,the first site listed, under Sun JDK 1.1.6 under Windows95. The software works well (note -- a patch to the just-in-time compiler for JDK 1.1.6 must be installed, or elserun without the JIT). Over the coming months we expectthe Kent and Twente teams to merge their efforts into onecommon platform.

The development of Java with CSP does not, however,solve the problem of explicitly assigning different threadsto different processors for true parallel computing. Atsome point, the operating systems for multiprocessorsshould catch up and make such assignment automatic. Itwould also be useful if control over the assignment ofthreads to different processors could be underprogrammer control. For now, it is possible to get accessto thread control on multiple processors by using SunMicrosystems JDK 1.2 for Solaris 2.6, [4-20]. This JDKhas an interface to the native Solaris multithreadinglibrary and allows the applications programmer to set thenumber of physical CPUs over which the Java threads willbe distributed. However, this approach in itself doesnothing to hide the complexities and subtleties of Javamonitors from the programmer. It may be possible tocombine this approach with a tool such as Java with CSP


to get both control over the number of processors and a"safe" parallel model.

Other efforts to develop tools for parallel computing withJava include implementations for PVM and MPI. Theseare discussed below in the context of advanced courses.

4.4 Introductory CoursesAn introductory course that uses Java can reasonablyinclude an introduction to concurrent and parallelcomputing. However, doing complex concurrentprograms using the Java supplied primitives forsynchronization rapidly becomes overly complex.Consequently, we recommend that at the introductorylevel, an introduction to concurrent and parallel programsbe based on the simplest constructs in Java, namely join(),or be based on a tool such as Java with CSP, as describedabove.

In the first instance, simple parallel programs can beconstructed by having a main thread start severalconcurrent threads, then wait for them to terminate byusing the join() method. In this way, parallel code withsimple barrier synchronization can be introduced.However, critical sections needed for concurrent writeaccess to memory would still depend on the complexitiesof Java monitors [4-8], which are better avoided at thislevel. Instructor supplied applets are useful inintroductory CS courses to demonstrate deadlock and raceconditions.

If one is ready to devote a larger portion of the course toparallel and concurrent computing, then Java with CSPtools provide a good alternative. The channelcommunications combined with parallel and selectionbased control of communications provides a mechanismfor concurrency which is straightforward and robust. TheJava with CSP tools include CSP channel-based version ofthe Java AWT interfaces, making it easy to buildgraphical interfaces which mesh with the Java with CSPcode. The University of Kent, U.K., has used thisapproach successfully with Occam 2, teaching concurrentand parallel computing to first year students. They plan tochange to Java in the near future, using the Java with CSPtools [4-23] [4-24].

Lynn Stein at MIT has proposed an approach similar tothe Kent approach for teaching introductoryprogramming. Here, using Java, interacting concurrentthreads comprise the fundamental model. Extensivematerials describing this approach are available at theWeb site [4-19] and the case is made for this approach inStein's paper [4-18].

4.5 Advanced CoursesJava provides the opportunity for studying concurrent andparallel constructs in some detail in higher level courses.Operating Systems, Systems Programming, or ParallelComputing courses are most likely to use these facilities.Other candidates include courses that make use of parallelcomputing, such as Computational Science or an

Algorithms course that includes an emphasis on parallelalgorithms. We discuss these alternatives under theheadings of Operating Systems and Parallel and HighPerformance Computing.

4.5.1 Operating SystemsThe primitive tools provided for concurrent control inJava (the monitor methods wait(), notify(), and notifyAll())are the basis for studying low-level concurrency control inan OS course. The proper use of these constructs can befollowed by the study of the difficulties that they raise,and the ease with which deadlock and race conditions caninadvertently be included in code, especially in thecontext of programs whose threads might be interruptedwith the interrupt() method. This leads naturally to adiscussion for the need for a better type of abstraction forconcurrent control, such as those provided by the Javawith CSP tools.

A second OS topic that can be raised in the context ofJava is the scheduling of concurrent threads. The Javathread scheduler, and its relationship to the OS scheduler,can be used as a case study. Issues of time-slicing forconcurrency, priority, and their dependence on theunderlying operating system can be studied in this context.Since Java does not provide a platform-independentscheduler, but relies on the underlying operating system,this leads to issues of the implementation of Java itself.

There are several sites on the Web about OperatingSystems courses that use Java. McCauley [4-16] has aWeb site with links to many of these sources, as will theWeb site developed in conjunction with this paper [1-4].The texts by Lea [4-14] and Hartley [4-9] contain much ofthe fundamental material on concurrency control thatwould be used in an OS course.

4.5.2 High Performance Parallel ComputingThe inclusion of threads in Java provides the opportunityfor doing parallel computing on a symmetricmultiprocessor (SMP) or on a network of workstations.The primitive control structures provided in Java are notappropriate for this type of computing, so an additional setof tools must be used.

The Java with CSP tools described above provide amessage-passing paradigm which can be used both onSMPs and on a network of workstations. The lack ofexplicit control of the scheduling of threads is currently adisadvantage of using the Java with CSP tools. However, aconcurrent program with reasonable slack in the parallelism(many more parallel threads than processors) should runwell on an SMP if the underlying OS schedules threadsacross the processors. Link drivers that provide formachine to machine connections mapped to CSP channelsare under development by the groups at the Universities ofKent and Twente. These will provide the tools needed fordeveloping message-passing parallel programs that can runon a network of workstations.


One advantage of the use of Java with CSP is that thesemantics of the language are compositional: controlconstructs can be understood locally and components canbe composed to construct larger components with well-defined and provably correct behavior.

Caromel and Vayssiere have developed a library forParallel, Distributed, and Concurrent Computing, ProactivePDC [4-2] [4-3]. This library provides facilities forworking with objects distributed among a network ofmachines cooperating on a parallel or concurrentcomputation.

Other groups have been developing tools for parallelcomputing in a Java environment based on tools previouslydeveloped for C or FORTRAN: MPI (Message PassingInterface) and PVM (Parallel Virtual Machine). Both MPIand PVM provide libraries for message-passing parallelcomputing for C and FORTRAN that can be used onnetworks of workstations for several different operatingsystems.

A project at the Georgia Tech Institute for SystemsEngineering under the direction of Christine Mitchell hasdeveloped a Java interface to PVM. The C-based PVMfunctions do the work, but the Java library provides Javainterfaces to this library, so that the main code can bewritten in Java. An on-line version of the system isavailable [4-17].

Two projects are underway to provide a Java interface forMPI, the recently developed standard for message-passingparallel programs. The Institute for SystemsProgramming in Rumania, with M. Domrachev, V. Etch,S. Gaissaryan, V. Ivannikov, and N. Shtaltovnaya, isdeveloping "Data Parallel Java," a library of Javawrappers for MPI message-passing functions.Information on this project can be found at the URL in [4-7]. The second MPI project is being developed byGeorge Crawford at MPI Software Technology, Inc. undera U.S. Department of Energy grant "Integrated MPI andJava for Commercial and Distributed Applications."Information on this project can be found at the sites [4-5]and [4-6].

The Cal Tech Structured Multithreaded ProgrammingProject, led by John Thornton and K. Mani Chandyprovides facilities for doing shared memory parallelcomputing in an environment which supports threads.This library has been developed for use with p-threads inUNIX or with Windows NT threads [4-21].

At this time the Java with CSP tools and the Georgia TechJava-PVM projects provide tools which can be downloadedand used. The other projects are under development andmay provide useful tools for parallel computing in thefuture.

5 COMPUTER NETWORKS5.1 OverviewIn this section, our goal is to investigate how Java may beused as a tool for teaching computer networks. If effective

models for teaching networking in Java can be developed,this may make it possible to teach the topic moreeffectively. Perhaps this will also facilitate the teaching ofnetworking more broadly throughout the computer sciencecurriculum.

Two particular strengths of Java for the topic addressed inthis section are:

• Multi-threading is an integral part of the language.

• Libraries are included to develop network-basedsoftware at several levels.

These particular strengths make Java an appealingplatform for teaching computer networks. Java allows thestudents to easily develop applications that communicateover the network and to understand how thatcommunication is done. Section 5.2 addresses how thesubject area can be treated in a course early in thecomputer science curriculum. Section 5.3 addressestreatment within an advanced course.

5.2 Teaching Networking at theIntroductory Level Using Java

The initial development of Java included libraries fornetwork programming. Consequently, writing programsinvolving network access is unusually straightforward.Early in their course, introductory students can writeprograms that use the network in a simple fashion. Laterthey can develop programs that access the network in anon-trivial manner.

The natural first introduction to networking is through thedevelopment and use of a Java applet. By the applet beingembedded in an HTML document and the student callingthe applet through a Web browser, the studentautomatically is using the network as the applet isretrieved from the Web server. The level of explanation ofhow the network is being used is not difficult. In fact,some CS1 textbooks [5-2], [5-14], [5-15] introduceapplets in the first few chapters. Interesting uses of appletsoften involve graphical programming (and the AWTpackage) so other CS1 authors [5-1][5-8] have chosen todelay introducing applets until after much of the basicmachinery of the language has been covered.

After an initial introduction to applets, the networkingaspects of Java can be extended through applets. Thejava.applet package contains the Applet class and thethree interfaces AppletContext, AppletStub, andAudioClip. The URL class in the java.net package is usedto construct and inspect URLs. It should still be possiblenear the end of CS1 to have students write applets that usemethods from the java.applet package and the URL class.For example, an applet can be written [5-1][5-2] thatconstructs the URL of a file that contains an image or anaudio clip, downloads that file, and displays the image orplays the audio clip.

Java can also be used in another manner that isappropriate within CS1, especially a CS1 course that isbreadth-oriented. Java can be used as a tool for learning


networking concepts, instead of as a tool for learningnetworking programming. One such approach is to useJava applets that are interactive simulations that introducea networking concept. For example, Holliday [5-6] hasdeveloped three relevant applets. One applet illustratesencapsulation as a packet moves through the protocollayers on the source host, intermediate routers, anddestination host. A second applet illustrates the mediaaccess protocol used by Ethernet. A third applet illustrateserror recovery mechanisms suitable for the transport layer.These applets were designed for the non-major course butcould also be used in courses within the major.

A second approach is to use programs written in Java forlive protocol demonstrations. For example Harold [5-5]has written two simple Java programs, javalookup andclientTester that can be used in assignments [5-6].Javalookup is similar to the nslookup utility and can beused to demonstrate domain name resolution; the studentcan convert between an Internet domain name and an IPaddress. ClientTester listens on a TCP port and displays tostandard output any messages received. ClientTester,telnet, a Web browser, and a Web server can be used toillustrate the messages sent by HTTP during a Web pageaccess. In a later course the student can study the code ofthese programs instead of just using them.

5.3 Teaching Networking at the AdvancedLevel Using Java

Just as Java triggers changes in CS1 by the inclusion ofsome networking features, Java also triggers changes in anetworking course aimed at the junior/senior level. One ofthe significant features of Java is that it dramaticallysimplifies socket programming (that is, programming atthe level of TCP and UDP). In fact Java socketprogramming is even included in some CS1 textbooks [5-1]. Socket programming in C or C++ is more complex andtedious with no additional gain in understanding. Anotherachievement is how well Java supports Web programmingboth client-side and server-side. Finally, Java’s RMI(Remote Method Invocation) is a natural way to introducedistributed object-level programming.

Paul Tymann’s slides [5-21] from his Introduction to JavaNetworking tutorial at SIGCSE’98 are an excellentintroduction to network programming using Java. TheJava Tutorial maintained by Javasoft [5-9] is an in-depthcoverage of most of the Java language features includingthe networking features. The version of the Java Tutorialthat is maintained on the Web is continually beingupdated. The Operating Systems, Parallel Computing, andNetworks section of Renee McCauley’s Computer ScienceEducation Links page [5-17] has some networking linksthat are relevant. The Web page for the ComputerNetworks textbook by Peterson and Davie [5-19] has alink to socket programming assignments that have beendeveloped by a number of instructors. These assignmentshave not, in general, been developed using Java, but couldeasily be adapted to a networking course that uses Java.

Though Harold’s Java Network Programming [5-5] wasnot written as a textbook, the order in which he presentsprogramming topics can be effective in a networks courseas described in the rest of this section. The code for all theexamples in Harold (and some of the other booksmentioned below) is available on the Web. Beforeencountering socket programming, interesting assignments[5-7] (such as the javalookup program mentioned above)are possible using some of the simpler classes in thejava.net package, InetAddress, URL, and URLEncoder.Socket programming can start with TCP clients using theSocket class and TCP servers using the ServerSocketclass. The clientTester program mentioned above is oneexample of using the ServerSocket class; simple HTTPand proxy servers are other examples [5-5][5-4][5-10]. Ifthe students have not seen Java threads before, threadswill need to be introduced, as TCP servers are covered [5-3]. Using one thread to listen for new connections and anew thread to service each connection is a very commonTCP server design feature.

Once the students are comfortable with TCPprogramming, the two UDP classes, DatagramPacket andDatagramSocket, can be introduced for both clients andservers [5-5][5-10]. For example, Holliday [5-7]developed two assignments. In the first assignment thestudents implemented a chat client and a multithreadedchat server (with synchronized access to the shared log ofmessages) using the TCP classes. In the secondassignment, the students re-implemented the chat clientand server using the UDP classes. The MulticastSocketclass is a subclass of the DatagramSocket class. It can becovered after unicast UDP programming to illustrate theperformance advantages of multicasting in somesituations.

In addition to socket programming, other features of Javanetworking support that should be covered are securityand cryptography, servlets, and RMI (Remote MethodInvocation). The instructor can show how thejava.security package can be used to add a securitymanager to a network server and to generate messagedigests and digital signatures, manage access control lists,and perform simple key management. David Flanagan’sJava Examples in a Nutshell [5-4] and Farley’s JavaDistributed Computing [5-3] have chapters illustratingusing this package. The Java Tutorial has subtutorials onsecurity in both JDK 1.1 [5-12] and in JDK 1.2 [5-13].

A servlet is a class written by the programmer toimplement the Servlet interface of the java.servletpackage. They, like CGI programs, are a way for a Webserver to dynamically generate data (such as HTML) to besent to a client. For example, the server-side includemechanism can be used to embed a servlet in an HTMLpage. Servlets are a useful example that the instructor canpresent as an alternative to CGI scripts and MicrosoftActive Server Pages [5-5][5-11].

A major step is to show students that larger and morerobust distributed applications should be built at a higher


level of abstraction than the socket level. In particular, theapplication should be composed as a collection ofcooperating and coordinating objects. Remote MethodInvocation (RMI) is a natural first method ofprogramming at this level to show the students since RMIis relatively simple and designed specifically for a Javaprogramming environment. RMI is implemented by thejava.rmi package. Explaining RMI motivates the need forobject serialization in order to marshal and unmarshal thearguments for a method invocation to a remote objectmachine. A number of relatively large RMI-baseddistributed applications are available in the literature andhave source code available on the Web. Flanagan [5-4]has code for a remote banking example and a MUD(Multi-User Domain) server and client. Farley [5-3]includes two extended RMI-based examples: a chatsystem and a shared whiteboard. Reese [5-20] has adistributed database system example based on RMI.

Once RMI is understood by the students, the instructorcan introduce RPC (Remote Procedure Call) as an earlierabstraction for distributed programming above the socketlevel. RMI is both a distributed object model and aparticular protocol, RMP (Remote Method Protocol) forimplementing the communication between objects. Thealternative distributed object models provided by CORBA(Common Object Request Broker Architecture), andMicrosoft’s DCOM (Distributed Common Object Model)can be compared with the RMI object model. CORBA’sIIOP (Internet Inter-ORB Protocol) can be compared withRMP. Recent developments in the support of RMI withinCORBA through RMI-over-IIOP (instead of over RMP)can be discussed.

Once the students understand the distributed objectmodels, the instructor can introduce the distinctionbetween two-tier and three-tier distributed applications.As a final step, JavaBeans and Enterprise JavaBeans canbe addressed. JavaBeans, supported by the java.beanspackage, is a component model. Any Java class thatconforms to the JavaBeans specification is a bean orcomponent. Building an object as a component (bean)helps to ensure that the object can be more easily used inbuilding a large application. For example, the JavaBeansspecification provides support for creating componentsthat have persistence and introspection. A persistentcomponent knows how to store its state when it isdeactivated and how to restore its state when it isreactivated. An introspective component can beassembled with other components into an applicationusing a visual assembly tool even if the component itselfis not visible when it executes.

The Enterprise JavaBeans API defines a server-sidecomponent model extension of JavaBeans as well as aframework for coordinators of server-side components.Coordinators of server-side components that arecompliant with Enterprise JavaBeans support distributedflat transactions in conformance with the CORBA ObjectTransaction Server specification. In fact, the entire

Enterprise JavaBeans specification, the java.ejb package,was carefully designed to be compatible with CORBA.Since CORBA does not include a framework for server-side component coordinators, Enterprise JavaBeanscomplements CORBA. Orfali and Harley [5-18] providea detailed discussion of RMI, CORBA, DCOM,Enterprise Java Beans and their use in multi-tierarchitectures. A Web site at Los Alamos NationalLaboratories [5-16] has an extensive collection of linksrelated to distributed object models, with an emphasis onCORBA.

6 DATABASE6.1 OverviewThe initial release of Java (Java 1.0) provided only thebasic level of functionality needed to develop applets andapplications. Later releases (Java 1.1 and 1.2) saw thisbasic functionality grow beyond the core API to includeother APIs as well. One of these APIs, the Java DataBaseConnectivity API, or JDBC, provides databaseconnectivity support allowing programmers to accessdatabases on the Internet and to send SQL commands tothese databases as arguments to methods of the JDBCinterfaces. The JDBC API is available in the java.sqlpackage, which is included in the JDK distribution.

By providing this level of support, Java makes it possiblefor students at all levels, from introductory to advanced, towork with databases in their programs. At the introductorylevel it maybe merely to use the database as a source ofdata in the simplest of client-server models; at theadvanced level their use may be included as part of amulti-tiered distributed database architecture.

6.2 Using Java to Teach Databases at anIntroductory Level

Late in a CS1 course or sometime in a CS2 course,databases can be introduced as the last phase in a naturalprogression for program input. The progression willusually begin with input entered by a user, move on toinput streams, and to databases accessible via a network asanother source. In addition, instead of merely being asource for unprocessed data, as is the case with user-supplied input or data from an input stream, the data madeavailable via the database comes because of a databasequery. This affords the student a first glance at a client-server architecture.

At any level, exposing students to databases with Java andJDBC requires that, on the database side, they knowsomething about (relational) database concepts and SQL.On the Java side they must use URLs, database drivers,and the JDBC classes and interfaces. Fortunately thedepth of knowledge required in all of these can besufficiently scaled down to make it feasible to use them atan introductory level.

With respect to database concepts, a student can managequite easily knowing only the fundamental structures ofrelational databases -- relations/tables, tuples/records, and


fields (with their associated names and types). Likewiseonly the simplest form of SQL’s SELECT commandneeds to be furnished, although including the WHEREclause would help provide the front-end processing whoseuse would take us to a client-server model. Theintroduction to SQL on pages 13-17 of Reese [6-16], forexample is more than sufficient for this purpose.

As for Java, using the JDBC classes, interfaces, andmethods would become just one more learning experiencein what is becoming a familiar pattern to the student. Wepoint out here a few ideas for scaling down some of theconcepts that might be troublesome to introductory-levelstudents.

For network connectivity, if the introduction of JDBCfollows an introduction to networking, the student wouldalready be familiar with URLs. However, Java avoids thenetworking background problem because one does notneed to know anything about the URL class in order toaccess a remote database through JDBC. The URL issupplied as a String argument to the getConnection()method of the DriverManager class. To assistintroductory level students the instructor can supply anexample of such an argument and the students can use itas a model that can be adapted to a specific databasereference. The only portion of the URL that might puzzlethe student is the reference to the driver subprotocol thatprecedes the database location. This can be explained,however, as one of those things that has to be present inorder to connect to the database. The following referencesdeal with Java programming and JDBC, providingsuitable examples for specifying database URLs: [6-4] –[6-7], [6-9], [6-10] –[6-16].

The situation with database drivers is similar to that ofURLs. Again, it is unnecessary for the students to acquirea detailed knowledge of what such drivers are and thevarious classes of drivers used in JDBC. The referencesprovide suitable background material on drivers for thosewho want more details. For the instructor, getting adatabase set up and having the correct drivers availablefor accessing the database requires some attention.Sources such as Chapter 16 of Flanagan’s book [6-6] andChapter 2 of Hamilton, Cattel and Fisher’s book [6-7]should be helpful here. All JDBC applications require thatthe programmer register a Driver class with theDriverManager. Since the easiest way to register a driveris with the Class.forName() method invocation, whichtakes the driver designation as a String argument, theinstructor can provide a driver designation for eachdatabase to be used and then rely on the student'sinductive abilities to modify them appropriately. It shouldbe noted that the availability of JDBC drivers for anumber of database management systems is still relativelylimited. Even those that are available may imposelimitations on what can be done with a given database.Kingsley Idehen [6-10] points out some of the advantagesand disadvantages of the various types of drivers(including the restrictions some impose).

Once a database connection has been made, and thisexercise can be the first part of a multi-part assignment ora short assignment in its own right, a simple SELECTcommand can be sent to the database as a String argumentusing the executeQuery() method of a Statement object.The results are then collected in a ResultSet object andprocessed iteratively. Orfali and Harkey [6-15] provide ascenario (but no code) for such a transaction. Otherauthors, for example [6-6], [6-7], [6-9], or [6-16], providecode. Once the ResultSet object is processed, we need nofurther use of JDBC except for closing the database.Depending on the depth to which user interfaces havebeen covered, output can be delivered to standard outputor presented more graphically using classes from theAWT.

As a final note, while our discussion has focused onscaling down JDBC and database concepts forintroductory level students, other options are possible. Forexample, the instructor may develop a class library, oreven have the students run a pre-built applet that generatesmost of the tables automatically by having the student fillin a form. In the latter case, if desired the resulting JDBCcode and SQL can be executed as well as shown.

6.3 Using Java to Teach Databases at anAdvanced Level

The likely target for the use of Java and JDBC for upperlevel students is in a database course. We shall assume thestudent has already done some programming in Java andthat SQL will be covered in the course, or otherwiselearned by the student.

In this section we focus on providing a sequence ofprogressively more sophisticated exercises that could beincorporated into a database course as time and theinterest of the instructor allows. Mark Holliday hasavailable on-line [6-8] two handouts describing one suchexercise that he uses in a database course.

Although we shall not venture into object-orienteddatabases here, Barrett R. Bryant [6- 2] has available on-line, a module “Java as an OODB ProgrammingLanguage” that shows how Java may be used as aprogramming language for studying object-orienteddatabases. It is designed to complement the discussion ofobject-oriented databases given in Ullman’s book [6-20].

We now describe one sequence of exercises that we feelcan be useful for students:

1. The student can begin with an exercise similar to thatdescribed in section 6.2 for the introductory levelstudent -- access an existing database and execute asimple SQL query. This exercise could either serve asa review for those who have already worked withJDBC, or be an introductory exercise for new JDBCusers.

2. As a follow-up to the exercise above, the student canwrite a program to modify a database relation/tablevia the executeUpdate() method available to


Statement objects. Once again, any of the references,[6-4] – [6-7], [6-9], [6-10] – [6-16], provideexamples. Once this has been done successfully, theinstructor may wish to pursue some topics thatgeneralize or optimize the student’s work thus far:

• Use the execute() method with an arbitrary SQLcommand as an argument rather than relying onthe more restrictive executeQuery() andexecuteUpdate() methods. This allows thestudent to specify the type of databasetransaction to be performed dynamically ratherthan statically.

• Use prepared statements and stored proceduresto show how the run-time efficiency of somedatabase transactions can be improved. Onceagain most of the textbook and tutorial referencescover prepared statements and stored procedures.Reese [6-16] gives an example where codeinvolving SQL calls is re-done using storedprocedures.

• Use the classes DatabaseMetaData andResultSetMetaData to allow a program toretrieve information about a database's structureor a result set's make-up dynamically. Thisprovides more flexibility than having thedatabase's relation names and each relation's fieldproperties embedded in the code. All of thereferences ([6-4] – [6-7], [6-9], [6-10] –[6-16])discuss the “meta classes.”

3. Building on the foundation established above, oncestudents have successfully embedded SQL commandsin a program and connected to a database, it is asimple step to move this code to the run() method fora thread. This lets multiple threads access a database.By varying the ways in which the threads aresynchronized to access the database, one can exploreconcurrency and transaction management problemsfor databases. Issues of transaction management forsingle database systems are described in Ullman [6-20].

4. As a natural follow-up to the previous exercise, athread can read from two or more databases. Thisintroduces issues related to distributed databases,especially issues surrounding the distribution of dataamong sites and data redundancy among these sites.An introduction to distributed databases can be foundin Ceri and Pelagatti [6-3]. This exercise should berestricted to performing only reads on the database inorder to avoid more complex transaction managementissues.

5. In the previous item, we simply had the students readfrom a distributed database. For this case, it does notmatter if the records retrieved from each database hadcommon fields, as long as we are assured that dataconsistency exists for these records. A moreambitious exercise asks students to perform multiple

concurrent transactions on a distributed database thatinvolve intermixed reads and writes. This nowrequires the student to explore issues of dataconsistency, multi-phase locking protocols, and multi-phase commit schemes and rollbacks. These conceptsare discussed in Ceri and Pelagatti [6-3] and Ullman[6-20].

Many of the Java programming books that emphasizedatabases and JDBC ([6-7], [6-9], [6-11], [6-15], and [6-16]) develop a client-server application, such as a serverfor a bank, that fully exercises JDBC. David Flanagan [6-6] also provides such an example in chapter 16 of hisbook. Examples that are even more extensive exist forthose who want to venture beyond the two-tier, client-server models we have been using here and to delve intothree-tier models. The three-tier architecture uses a middlelevel that comes between the client system and thedistributed data stores to insulate the details of the datadistribution from the clients. The middleware makes thedata of the database available in the form of remoteobjects whose data values are mapped to an appropriatedata store by the middleware. This allows the clients towork with data in the form Java supports most naturally,namely objects. Accessing remote objects is beyond thecapabilities of JDBC. Conveniently, Java has the RemoteMethod Invocation (RMI) API available for this purposein the java.rmi package. Examples of three-tier modelsdeveloped using RMI can be found in Orfali and Harkey[6-15] and in Reese [6-16].

7 OTHER COURSES IN WHICH JAVACAN BE USEFUL

Many other courses can use Java effectively. Many of theresources referenced in the previous sections are alsouseful in other courses. In this section we briefly review acouple other courses where Java could be used.

7.1 Compiler ImplementationJava has been effectively used in compiler development.The lack of pointers and the subscript bounds checkingprovided by the language prevent a large number ofstudent errors. Bergin noticed a general increase in thelevel of quality of completed projects and an increase inthe number of successful completions when Java replacedC++ in a compiler construction course. References tothree course outlines for the compiler implementationcourse follow:

• Appel: [7-1] This course is very complete with anassociated book by Andrew Appel. It uses tools,similar to lex and yacc, written in Java and availableover the Web.

• Bergin: [7-2] This is a much simpler course that usesLL(1) parser tools and develops a compiler feature byfeature rather than pass by pass.

• Budd: [7-3] This course is also lex and yacc based.The site includes on-line lecture notes, source codeand a complete set of assignments.


7.2 Human Computer InteractionIn some ways, Java is ideal for exploring HCI issues. Thebuilt-in libraries facilitate graphical interface developmentand so various interface designs can be explored with littledifficulty. However, this assumes that only standardelements will be used. Harder, but possible, is theexploration of non-standard elements such as pie shapedmenus. Some references are:

• Terry Harpold [7-4] at Georgia Tech maintains apage of resources for multimedia designers. Some ofthis is related to HCI and some to Java .

• N. Hari Narayanan [7-5] has a course on HCI. Itcontains many projects. Some of them are Javaspecific.

• Pacific Bell [7-6] maintains a page of GUI toolkitresources. Some are HCI related and some Javarelated.

8 CAPSTONE COURSEA capstone course can be either an integrated project-based course or a seminar-based course. Such a coursecan utilize many of the resources mentioned elsewhere inthis paper. In particular, such a course can requireconcurrent programming, database programming, Internetprogramming, or combinations of these. The course canalso incorporate human computer interaction issues andgraphical interface design. Finally, such a course canemphasize good object-oriented analysis and design. Allof these are facilitated by use of Java. Some referencesare:

• Information about a project based advanced coursecan be found at Pace University [8-2]. This sitecontains pointers to a large number of OO and Javaresources, including tutorials and tools.

• Kalamazoo College requires a capstone senior projectof all students. Information on these requirements canbe found at [8-3].

• The University of Durham requires a final yearproject of most information technology majors. Thisis described in [8-1]. The course description can befound at [8-4]

• Kris Powers describes a course in Parallel Computingas a Capstone Experience in [8-5]. This is not Javaspecific, but the ideas may be adapted to Java usingresources mentioned elsewhere in this report.

• Ronald Dattero teaches a projects course emphasizingSystems Development in Java. The course page canbe found at [8-6]. A few different projects aresuggested here, as well as a syllabus. The site alsopoints to a number of useful resources.

9 CONCLUSIONS AND FUTUREDIRECTIONS

We found Java useful at many points in the curriculum.There are a large number of resources available in print

and on-line to aid the instructor in the preparation of newand revised courses. The language itself facilitates thisprocess of course preparation and delivery by providingtools that can be used to build artifacts that illustrate theessential ideas of computing. These artifacts can bedesigned in a way that can be used, examined, extended,and emulated by students.

Java makes some topics accessible early in the curriculumthat have traditionally been considered very difficult fornovices. Early introduction of such topics can lead tomore breadth in the early courses, giving students a betterview of the profession, without necessarily sacrificingrigor or depth. This approach, however, requires theinstructor to prepare materials in advance and carefullythink about their impact. Viera Proulx of NortheasternUniversity has observed that in literature courses we askthe students to examine artifacts that are much moresophisticated than they could produce themselves. Shesuggests that we can do the same in computing sciencecourses if we have excellent resources. We hope thisreport will help in the preparation, identification, anddistribution of such resources.

With this report, the authors have taken an initial step inan ongoing process. A copy of this report will bemaintained and updated on the Web atsol.pace.edu/iticse98/. As additional materials and toolsbecome known to the authors, they will be added to thesite.

10 ACKNOWLEDGEMENTS:Our thanks to ACM, SIGCSE, SIGCUE, ITiCSE98, theCentre for the Teaching of Computing at Dublin CityUniversity, and the Computers in Teaching InitiativeCentre for Computing (CTI) at the University of Ulster forproviding facilities and help in the preparation of thisreport.

The working group co-chairs, Bergin and Naps, wouldespecially like to thank the members of the group for theirwork in the preparation of this report and their patiencewith the chairs throughout the process.

11 REFERENCESSection 1 - Introduction:[1-1] Biddle, R. and Tempero, E., Java Pitfalls for

Beginners, in SIGCSE Bulletin (June 1998). [1-2] King, K.N., The Case for Java as a First Language,

in Proceedings of the 35th Annual ACM SoutheastConference (Murfreesboro, Tenn., April, 1997).

[1-3] Tyma, P., Why Are We Using Java Again, inCommunications of the ACM (June, 1998).

[1-4] sol.pace.edu/iticse98

Section 2 – Java-Based Introductory Courses with anEmphasis on Using Graphics and VizualizationResources:


[2-1] Ben-Ari, M., Distributed algorithms in Java. inProceedings of ITiCSE’97 (Uppsala, Sweden, June1997) 62-64.

[2-2] Ben-Ari, M., Concurrent Programming page:stwi.weizmann.ac.il/g-cs/benari/cp.htm

[2-3] Bush, B., Banda Packages: www.sladen.com/Java/[2-4] Dehne, F. K. H. A.,

www.scs.carleton.ca/~dehne/tools/java/[2-5] Drossos, N., Papagelis, A., and Papaioannou, P. ,

students.ceid.upatras.gr/~papagel/project/contents.htm

[2-6] Haajanen, J., Pesonius, E, Sutinen, E., Tarhio, J.,Teräsvirta, T., and Vanninen, P., Animation of useralgorithms on the Web. in Proceedings of VL '97,IEEE Symposium on Visual Languages, (Capri,Italy 1997), 360-367.

[2-7] Horstmann, C., Computing Concepts with JavaEssentials. Wiley, New York, 1997.

[2-8] Kluit, P.G., Sint, M., and Wester, F., VisualProgramming with Java: Evaluation of anIntroductory Programming Course. In Proceedingsof ITiCSE’98, (Dublin, Ireland, August 1998), 143-147.

[2-9] Kluit, P.G., Sint, M., and Wester, F., Visualprogramming with Java; an alternative approach tointroductory programming in Proceedings ofITiCSE ‘97 (Uppsala, Sweden, June 1997) 57-58.

[2-10] Kluit, Sint, and Wester websites, www.ouh.nl/[2-11] Lawhead, P., and Wilkins, D.,

eliot.cs.olemiss.edu/jade/[2-12] Lea, D., g.oswego.edu/dl/html/javaINCS.html[2-13] McNally, M., Using Image Processing as a

Laboratory Theme in CS1 and CS2. to appear inthe Journal of Computing In Small Colleges, seealso charis.mcs.alma.edu/~mcs/image/.

[2-14] Martin, P., Java, the good, the bad and the ugly.ACM SIGPLAN Notices, V. 33(4) April 1998, 34-39.

[2-15] Martin, P., Java course page,www/csm/uwe/ac/uk/~pcmarti/javacourse/javacourse.html

[2-16] Naps, T. L., A Java Visualizer Class: IncorporatingAlgorithm Visualizations into Students’ Programs.In Proceedings of ITiCSE’98 (Dublin, Ireland,August 1998), 181-184.

[2-17] Naps, T. L., A. WebGAIGS pagegaigs.cmcs.lawrence.edu/

[2-18] Proulx, V., Recursion and Grammars for CS2. inProceedings of ITiCSE’98, (Uppsala, Sweden,June, 1997).

[2-19] Roberts, E., and Picard, A., Designing a JavaGraphics Library for CS1. In Proceedings ofITiCSE’98 (Dublin, Ireland, August 1998), 215-218.

[2-20] Rodger, S.,www.cs.duke.edu/~rodgers/tools/tools.html

[2-21] Rodger, S., JFLAPwww.cs.duke.edu/~magda/flap/index.html

[2-22] Roehl, B., et al., Late Night Vrml 2.0 With Java.Ziff Davis Pr; ISBN: 1562765043, 1997.

[2-23] Stasko, J., Tango: A Framework and System forAlgorithm Animation; IEEE Computer, September,1990.

[2-24] Stasko, J., Using Student-Built AlgorithmAnimations as Learning Aids. In Proceedings ofthe SIGCSE Session, ACM Meetings (San Jose,CA., February, 1997).

[2-25] Stasko, J., Software visualization at the GVU.www.cc.gatech.edu/gvu/softviz/

[2-26] Stegink, G., www.cs.hope.edu/csci120[2-27] Stein, L., Reconceptualizing Computation:

Radically Rethinking CS1.www.ai.mit.edu/people/las/papers/cs101-proposal.html

[2-28] Stein, L., www-cs101.ai.mit.edu[2-29] Sutinen, E., Tarhio, J., and Teräsvirta, T.,

www.cs.helsinki.fi/research/aaps/Jeliot/[2-30] Tyma, Paul: Why are we using Java again?, CACM

June 1998, 41,6, 38-41[2-31] Weiss, M. A., Experiences teaching data structures

with Java. SIGCSE Bulletin vol. 29, no. 1, 164-168.[2-32] Wikla, A., www.cs.helsinki.fi/~wikla/JohdOhj/[2-33] www.acme.com/java/software/[2-34] www.softbear.com/people/larry/[2-35] simon.ct.vt.edu/SoSci/index_links

/progress.html[2-36] www.objectspace.com/jgl

Section 3 – Software Engineering:[3-1] Bergin, J., csis.pace.edu/~bergin[3-2] Boroni, C. M., Goosey, F.W., Grinder, M.T., and

Ross, R.J., “A Paradigm Shift! The Internet, theWeb, Browsers, Java and The Future of ComputerScience education”, Proceedings of the Twenty-Eighth SIGCSE Technical Symposium onComputer Science Education, 1997, p.145.

[3-3] Gamma, Helm, Johnson, and Vlissides, DesignPatterns: Elements of Reusable Object-OrientedSoftware, Addison-Wesley, 1995.

[3-4] Gosling, Joy, and Steele, The Java LanguageSpecification, Sun Microsystems, 1998.

[3-5] Larman, G., Applying UML and Patterns, Prentice-Hall, 1997.

[3-6] Lewis, J., and Loftus, W., Java Software Solutions:Foundations of Program Design, Addison-Wesley,1998.

[3-7] Moss, E., invited talk at OOPSLA ’97, Atlanta,Georgia.

[3-8] Reilly, D., www.inside-Java.com/articles/uidesign[3 9] Schach, S., Software Engineering with Java, Irwin,

1998[310] Singhal, Sandeep, and Binh Nguyen, “The Java

Factor,” Communications of the ACM, June 1998,Vol. 41, No. 6, p. 34.

[3-11] Symes, K., www.sm.luth.se/csee/courses


[3-12] Tyma, P., “Why are we using Java again?”Communications of the ACM, June 1998, Vol. 41,No. 6, p. 38.

[3-13] Waldo, J., “Dynamic Lingo,” UNIX Review’sPerformance Computing, July 98, Vol. 16, Issue 8,p. 25.

[3-14] cs.lasierra.edu/~netprogram[3-15] edlab-www.cs.umass.edu/~lerner/[3-16] java.sun.com/docs/books/tutorial/essential/

exceptions[3-17] www.artima.com/flexiblejava[3-18] www.caip.rutgers.edu

/~marsic/Teaching/14:332:472.html[3-19] www.dcs.napier.ac.uk/~ooseb[3-20] www.heinz.cmu.edu/project/java/labs/lab4/

lab4.html[3-21] www.math.luc.edu/~laufer/courses/473[3-22] www.rational.com[3-23] www.redbooks.ibm.com/SG242232

/javac10.html[3-24] www2.ai-lab.fh-furtwangen.de/~bless/

UMLEditor/index.html

Section 4 – Parallel and Concurrent Programming UsingJava:[4-1] Austin, P., JCSP Web page.

www.cs.ukc.ac.uk/projects/ofa/jcsp/[4-2] Caromel, D., and Vayssiere, J., ProActive PDC

Web site. www.inria.fr/sloop/javall[4-3] Caromel, D., and Vayssiere, J., A Java Framework

for Seamless Sequential, Multi-threaded, andDistributed Programming. ACM Workshop: Javafor High-Peformance Network Computing(Stanford University, March, 1998) 141-150.

[4-8] www.mcs.drexel.edu/~shartley/ConcProgJava/Labs/ multithreadedAQ.html

[4-4] Chalmers, A., JavaPP Web page at Bristol.www.cs.bris.ac.uk/~alan/javapp.html

[4-5] Crawford, G., JMPI description. mpi.mpi-softtech.com/publications/JMPI_121797.html

[4-6] Crawford, G., JMPI proposal.sbir.er.doe.gov/sbir/cycle15/phase1/abstract/70.htm

[4-7] Domrachev,M., V. Etch, S. Gaissaryan, V.Ivannikov, and N. Shtaltovnaya. DPJ World WideWeb page. www.ispras.ru/~dpj

[4-9] Hartley, S., Concurrent Programming: The JavaProgramming Language, Oxford: OxfordUniversity Press, 1998.

[4-10] Hilderink, G., Broenink, J., Vervoort, W., andBakkers, A., Communicating Java Threads. In A.Bakkers, Editor, Parallel Programming and Java,Proceedings of WoTUG 20, v. 50 of ConcurrentSystems Engineering (Amsterdam, 1997), IOSPress.

[4-11] Hilderink, G., JavaPP World Wide Web page atTwente. www.rt.el.utwente.nl/javapp/

[4-12] Hoare, C.A., Communicating Sequential Processes.CACM (August, 1978) 21(8):666-677.

[4-13] Hoare, C.A., Monitors: an operating systemstructuring concept. CACM, (October, 1974)17(10):549-557.

[4-14] Lea, D., Concurrent Programming in Java. NewYork: ACM Press, 1996.

[4-15] Lewis, T., The Binary Critic. IEEE Computer(March, 1997), 17(3):134.

[4-16] McCauley, R., Computer Science Education LinksWorld Wide Web page.www.cacs.usl.edu/~mccauley/edlinks

[4-17] Mitchell, C., JavaPVM World Wide Web page.www.isye.gatech.edu/chmsr/jPVM

[4-18] Stein, L., What We Swept Under the Rug:Radically Rethinking CS1. To appear in ComputerScience Education.www.ai.mit.edu/people/las/papers/rug.html

[4-19] Stein, L., Rethinking CS101 World Wide Webpage. www.ai.mit.edu/projects/cs101 /publications.html

[4-20] Sun Microsystems, Inc. Java World Wide Webpage. www.sun.com/solaris/java

[4-21] Thornton, J., Cal Tech Structured MultithreadedProgramming ProjectWorld Wide Web page.threads.cs.caltech.edu.

[4-22] Welch, P., Java Threads in the Light ofOccam/CSP. In A. Bakkers, editor, ParallelProgramming and Java, Proceedings of WoTUG20, v 50 of Concurrent Systems Engineering,Amsterdam:IOS Press, 1997

[4-23] Welch, P., Parallel and Distributed Computing inEducation. University of Kent, U.K., 1998.

[4-24] Welch, P., Teaching How to Use Java for Paralleland Multi-threaded Computing. Panel presentationfor panel "Using Java in Computer ScienceEducation," at ITiCSE'97 conference, Uppsala,Sweden (June, 1997).www.cs.rit.edu/~ncs/Uppsala97

Section 5 – Computer Networks:[5-1] Bishop, J., Java Gently, Second Edition, Addison-

Wesley, Reading, MA, 1998.[5-2] Decker, R., and Hirshfield, S., programming.java,

PWS Publishing, Boston, MA, 1998.[5-3] Farley, J., Java Distributed Computing, O’Reilly,

Sebastopol, CA, 1998.www.oreilly.com/catalog/javadc/noframes.html(code examples:ftp://ftp.ora.com/published/oreilly/java/javadc/)

[5-4] Flanagan, D., Java Examples in a Nutshell,O’Reilly, Sebastopol, CA, 1997.www.oreilly.com/catalog/jenut/noframes.html(code examples:www.oreilly.com/catalog/jenut/examples/)

[5-5] Harold, E.R., Java Network Programming,O’Reilly, Sebastopol, CA, 1997.www.oreilly.com/catalog/javanetwk/noframes.html(code examples:ftp://ftp.ora.com/pub/examples/java/java.netprog/)

http://www.ai.mit.edu/projects/cs101


[5-6] Holliday, M.A., A Web-Based Introduction toComputer Networks for Non-Majors, ITiCSE’98,Dublin, Ireland, August, 1998. (www.cs.wcu.edu/~holliday/cware/)

[5-7] Holliday, M.A., A Web Page of SampleAssignments, www.cs.wcu.edu/~holliday/assgs/.

[5-8] Holmes, B., Programming with Java, Jones andBartlett, Sudbury, MA, 1998.

[5-9] Java Tutorial, Main World Wide Web Page,Javasoft, 1998.www.javasoft.com/docs/books/tutorial/index.html

[5-10] Java Tutorial, Networking subtutorial, Javasoft,1998. www.javasoft.com/docs/books/tutorial/networking/index.html

[5-11] Java Tutorial, Servlets subtutorial, Javasoft, 1998.www.javasoft.com/docs/books/tutorial/servlets/index.html

[5-12] Java Tutorial, Security in JDK 1.1 subtutorial,Javasoft, 1998. www.javasoft.com/docs/books/tutorial/security1.1/index.html

[5-13] Java Tutorial, Security in JDK 1.2 subtutorial,Javasoft, 1998. www.javasoft.com/docs/books/tutorial/security1.2/index.html

[5-14] Kamin, S.N., Mickunas, M.D., and Reingold, E.M.,An Introduction to Computer Science Using Java,WCB/McGraw-Hill, Boston, 1998.

[5-15] Lewis, J., and Loftus, W., Java Software Solutions,Addison-Wesley, Reading, MA, 1998.

[5-16] Los Alamos National Laboratories, CORBAResources World Wide Web page,www.acl.lanl.gov/CORBA/.

[5-17] McCauley, R., The Operating Systems, ParallelComputing, and Networks section of her ComputerScience Education Links page,www.cacs.usl.edu/~mccauley/edlinks/#OperatingSystems..

[5-18] Orfali, R., and Harkey, D., Client-ServerProgramming with Java and CORBA, SecondEdition, John Eiley, New York, New York, 1998.www.wiley.com/compbooks/.

[5-19] Peterson, L.L., and Davie, B.S., ComputerNetworks: A Systems Approach, MorganKaufmann, 1996. www.mkp.com/books_catalog/1-55860-368-9.asp(Socket assignment examples:www.mkp.com/books_catalog/cn/sockets.htm)

[5-20] Reese, G., Database Programming with JDBC andJava, O’Reilly, Sebastopol, CA, 1997.www.oreilly.com/catalog/javadata/(code examples:ftp://ftp.ora.com/pub/examples/java/jdbc/)

[5-21] Tymann, P., Introduction to Java Networking,Tutorial Slides from SIGCSE’98,www.cs.rit.edu/~ptt/talks/javaNetworking/index.htm.

Section 6 - Database:

[6-1] Baldwin, R., On-line Java tutorial. :www.phrantic.com/scoop/onjava.html

[6-2] Barret, R., OODB module. www.sun.com/products-n-solutions/edu/java/uab/index.html

[6-3] Ceri, S., and Pelagatti, G. Distributed Databases:Systems and Principles. McGraw-Hill, 1984.

[6-4] Chang, D., and Harkey, D. Data Access with Javaand XML. John Wiley and Sons, Inc. 1998.

[6-5] Cooper, J., Using JDBC to Create DatabaseObjects www.ibm.com/Java/education/jdbc-objects/

[6-6] Flanagan, D., Java Examples in a Nutshell.O'Reilly & Associates, Inc., 1997.

[6-7] Hamilton, G., Cattell, R., and Fisher, M., JDBCDatabase Access with Java: A Tutorial andAnnotated Reference. ACM Press, 1997.

[6-8] Holliday, M., A Web page of sample assignments :tinuviel.cs.wcu.edu/~holliday/assgs/

[6-9] Horstman, C., and Cornell, G., Core Java 1.1Volume II: Advanced Features (3rd ed.) SunMicrosystems Press, 1998.

[6-10] Idehen, K.,www.openlink.co.uk/info/docs/opljdbc.html

[6-11] Jepson, B., Java Database Programming. JohnWiley and Sons, Inc. 1996.

[6-12] MageLang Institute. JDBC Short Course.notes.krinfo.ch/jdbc/index.html

[6-13] MageLang Institute. JDBC Short course exercisesnotes.krinfo.ch/jdbc/jdbc/exercises.html

[6-14] Manning M., Teach Yourself Borland JBuilder in14 Days] Sams.net Publishing, 1997.

[6-15] Orfali, R., and Harkey, D., Client ServerProgramming with Java and CORBA (2nd Ed.).John Wiley and Sons, Inc. 1998.

[6-16] Reese, G., Database Programming with JDBC andJava. O'Reilly & Associates, Inc., 1997.

[6-17] Sun Microsystems JDBC FAQwww.javasoft.com/products/jdbc/jdbc-frequent.html

[6-18] Sun Microsystems JDBC Overviewwww.javasoft.com/products/jdbc/overview.html

[6-19] Tanler, R., The Intranet Data Warehouse: Toolsand Techniques for Building an Intranet EnabledData Warehouse. John Wiley and Sons, Inc. 1997.

[6-20] Ullman, J., Principles of Database andKnowledge-Base Systems Vol.1. Computer SciencePress, 1988.

[6-21] Yang, A., Linn, J., and Quadrato, D., "DevelopingIntegrated Web and Database Applications UsingJava Applets and JDBC Drivers." ACM SIGCSEBulletin

Section 7 – Other Courses in which Java Can Be Useful:[7-1] www.cs.princeton.edu/courses/

archive/fall96/cs320[7-2] csis.pace.edu/~bergin/Compiler.htm[7-3] www.cs.orst.edu/~budd/480.html[7-4] www.lcc.gatech.edu/~harpold


/resources/mm.html[7-5] www.eng.auburn.edu/department

/cse/research/vi3rg/teaching/hci.html[7-6] home.pacbell.net/atai.guitool

Section 8 – Capstone Course:[8-1] Boldyreff, Bennett, Munrow, and Smith, Final Year

Projects: Practice and Experience, Monitor:Journal of the CTI Centre for Computing Number

9, Spring 1998, (ISSN 09161-3757) or atwww.ulst.ac.uk/cticomp

[8-2] csis.pace.edu/~bergin/Java/StudentTasks.html[8-3] www.kzoo.edu/expProg.html[8-4] www.dur.ac.uk/~dcs0www/ug

/y3proj/project.html[8-5] www.uis.edu/~mcc97/html/papers/powers[8-6] www.fau.edu/divdept/cobus/dis/sdp-ec/sdp

Java Resources for Computer Science...

Documents

Transcript of Java Resources for Computer Science...