Java Resources for Computer Science Instruction
Report of the ITiCSE98/ACTC98 Working Group on
Curricular Opportunities of Java Based Software Development
Dublin, Ireland August, 1998
Joseph Bergin (co-chair) Pace University, NYC firstname.lastname@example.org
Thomas L. Naps (co-chair) Lawrence University email@example.com
Constance G. Bland Mississippi Valley State University firstname.lastname@example.org
Stephen J. Hartley Drexel University email@example.com
Mark A. Holliday Western Carolina University firstname.lastname@example.org
Pamela B. Lawhead The University of Mississippi email@example.com
John Lewis Villanova University firstname.lastname@example.org
Myles F. McNally Alma College email@example.com
Christopher H. Nevison Colgate University firstname.lastname@example.org
Cheng Ng La Sierra University email@example.com
George J. Pothering College of Charleston firstname.lastname@example.org
Tommi Teräsvirta University of Helsinki email@example.com
This goal of this workgroup is to collect, evaluate, and foster the development of resources that might be used in new courses that emphasize object-oriented software development using Java or as components of more traditional courses at the introductory and advanced levels. Such courses could, for example, integrate internet distributed programming, concurrency, database programming, graphics and visualization, human interface design and object-oriented development. They could therefore also be suitable as capstone courses in computer science. The focus of the workgroup is on tools and techniques, including demonstrations, projects, syllabi, and pedagogical patterns. The participants are coordinating the development of a web site (http://sol.pace.edu/iticse98 ) devoted to sharing such tools and techniques among educators.
In the past few years a new opportunity has arisen to integrate a number of threads in computer science education. The internet, object-oriented programming, and especially Java, have made it possible to incorporate a broader range of material into one or more courses without necessarily sacrificing the depth to which other topics are explored. This new paradigm integrates at least software engineering, graphics/visualization, human interface design, concurrency, parallelism, networking, and database connectivity. Object-oriented mechanisms of design and programming can be an important element of such courses also. Rich content can be presented via visualization and animation tools. In introductory courses, students can be exposed to these topics at a high level of abstraction. At a more advanced level, instructors can bring the various threads from other courses together in a project/capstone course.
This main purpose of this workgroup is to collect, evaluate, and foster the development of resources that might be used in such new courses for which Java is the primary programming language. These courses may appear at the introductory level of the curriculum where, for years, computer science educators have debated the merits of a breadth-first approach versus a depth-first approach. In the former, students are exposed to many areas within the discipline of computer science but often at the expense of short-changing their skills at coding algorithms. In the depth-first approach, algorithmics are studied in much more detail, with students learning how to code algorithms in an appropriate language. However, students introduced to computer science via the depth-first methodology may have little idea of how their ability to code algorithms fits into the "bigger picture" of the discipline. With the abstractions offered by a language such as Java, the breadth-first and depth-first approaches can be combined in a new and exciting fashion. To help students understand basic algorithmic concepts and practice their coding skills, Java's system-independent graphics class libraries can be used to great advantage. Additionally, early in their studies, students can use Java to develop algorithms that manipulate powerful objects such as network sockets, parallel threads of execution, graphic user interfaces, and so on. By doing so, they hone their skills at developing algorithms while, at the same time, they see the role of such algorithms in more advanced areas of computer science.
At the advanced level, the fashion in which we teach subjects such as software engineering, networking, database, parallelism, and concurrency can be dramatically affected by using appropriate Java tools. Early in such upper level courses, the abstractions offered by class libraries can often make students' coding much simpler that it would otherwise be. By later studying the implementation techniques of such class libraries, we enable students to see clear illustrations of the importance of the algorithms that underlie the application programs. Finally, Java offers exciting new ways to integrate a variety of subjects into a senior-level capstone course.
Our focus is on discussing tools and techniques, including class libraries, demonstrations, projects, syllabi, and pedagogical patterns. Although a number of educators are teaching courses that contain some or all of these elements, currently there is a pressing need for the development of additional materials, projects, and curricular patterns. The workgroup has gathered many of the materials that already exist and will attempt to foster the development of new materials by creating a web site to disseminate the results [1,4]
A disclaimer needs to be made before proceeding further. The workgroup is not a Java advocacy group, nor is this paper promoting the adoption of a particular curriculum tailored to the language. There is no doubt that Java is a vastly over-hyped language. Wherever possible, we will attempt to point out some of the pitfalls of using Java in a particular context as well as the advantages. This workgroup is also not proposing to present a detailed analysis of all features of the language and their appropriateness for a particular curriculum. That has already been done in [1,1], [1,2], and [1,3]. Rather, our goal is to focus on the curricular opportunities afforded by the language.
In introductory classes, we can use graphics as an alternative output mode. This approach can and is being used to teach students about the full range of introductory programming concepts, from elementary data types and control structures to such topics as modular and object-oriented design, recursive algorithms, and introductory data structures. We don't need students to become experts at using a sophisticated graphics library but we do want them to become excited and enthusiastic about what they are doing. Graphics can often build such enthusiasm while at the same time clarifying and reinforcing the knowledge of programming language mechanisms and algorithms.
This type of programming needs a simple two-dimensional graphics library. For instance, for many years, instructors such as Viera Proulx [2,19] have had students use a simple turtle graphics library, not unlike LOGO, to produce fractals in their early programming assignments. Students find this more interesting than generating the Fibonacci numbers. The graphical output may itself be the goal of a programming assignment (draw concentric circles, produce a fractal, and so on) or it may be that we want a visualization to depict the actions of an algorithm (say shellsort) on data. We will refer to this distinction as graphics programming versus visualization in its use of graphical output. In the former, the emphasis is on having students make calls to graphic library routines to acquire practice in using various control constructs such as iteration and recursion. The goal of the student's program is merely to produce graphics output that requires these control constructs. In visualization, the emphasis is on having students use pre-built visualization tools to supplement their understanding of a non-graphic algorithm (such as sorting) that they are programming. In the subsequent parts of this section we discuss dealing with the Java graphics model and some of the resources available for use in Java-based introductory courses.
Instructors considering creating Java-based introductory courses that employ graphics and visualization would be well served to consider first a number of general issues regarding teaching with Java. A good place to begin would be the following three resources:
* Doug Lea in [2,12] has compiled a list of commonly asked questions that instructors might find helpful in setting up a first course. The article is somewhat dated (1996) but the issues raised in the article are still valid and informative. There are answers to questions like "Do I cover all classes in the CS1 class?" that will help in deciding the syllabus for the early classes.
* Paul Tyma's article [2,30] is filled with a discussion of features that make Java both appropriate and inappropriate as a language for teaching computer science. For instance, the effect of operating system idiosyncrasies on platform independence and the problem with user interfaces are explained.
* In [2,31] Mark Allen Weiss provides a candid discussion of experiences in porting his data structures course from C++ to Java. The paper is filled with ideas for scheduling topics, sample programming exercises, and potential pitfalls for first-time Java teachers. The absence of explicit pointers in Java is discussed, and Weiss maintains that this is really not an issue when teaching linked lists and trees in the course. In fact, Weiss finds that it actually reduces student program errors. Java's strengths and weaknesses are presented as well as student evaluations of the course.
Java, to our knowledge, is the only language that comes with a standardized built-in graphics library. Like everything else with Java, this graphics library is platform-independent, so we as instructors can easily trade ideas and exercises, and students can program on their own machine even if it is a different platform from what they use in the school's computer lab. Java is extensible, so instructors can easily customize the look and feel of Java programming by the creation of customized classes. This is all on the positive side.
On the negative side, Java's underlying graphics model has a number of problems, especially for students in introductory courses. As noted by authors such as Eric Roberts and Antoine Picard [2,19], Java suffers from:
* A device-oriented library so that graphics calls are made relative to a pixel-based coordinate system that is resolution dependent, with integral coordinates based on a non-Cartesian origin (the upper left corner). Such a coordinate system is difficult to use, even for experienced programmers. Introductory students think better in a Cartesian coordinate system or, for some recursive work, in a turtle-based graphics system.
* Forgetful bitmaps, in which the contents of graphical displays must be redrawn in response to events. This is not handled by the operating system, and must be done by the program. The refresh of sequential graphic displays is difficult.
* An almost stateless graphics context, which does not keep track of the current pen position or the position of drawn graphic objects. Having the graphics context maintain as much of its internal state as possible helps novice programmers.
Some of these issues are addressed in the 1.2 release of Java. However, the instability the language, and in particular the graphics library, will continue to remain a major concern for any instructor. A further complication is the general way that Java defers to the operating system in thread management, and only partially defers in regard to window management. Despite Java's claims of full-fledged system independence, often one can not be sure how threaded or windowed graphics programs will act on different platforms.
In response to these problems with the Java graphics model, a number of higher level Java graphics contexts have been created for use in introductory classes. In a number of cases, these also simplify or hide complexities in the Java's I/O, event, or applet models. Using these methods, students can write interesting graphics programs early in the course. Such contexts have been developed by each of the following individuals:
* Cay Horstmann [2,7] provides classes that integrate the graphics and event models (as well as simpler I/O methods) as part of his recent Java textbook. An example of this is a line drawing method which captures mouse clicks to define the start and end points of a line which is then drawn. Students do not need to know the underlying details of the supporting event model.
* Thomas Naps [2,17], at Lawrence University, uses a turtle-graphics library for assignments that involve recursive fractal drawing. This approach handles the problem of the relative statelessness of the graphics context and the device oriented nature of the graphics model.
* Eric Roberts and Antoine Picard [2,19], at Stanford University, designed a library to address the three main problems mentioned above. Their approach employees a graphics context, which keeps track of current state, tracking the graphics objects that compose it. Source code for this library's Java classes is available online.
* Gordon Stegink [2,26] teaches an introductory course at Hope College that takes a totally graphics and applet-based approach. He provides a foundation class through which all the applets are written. His course does not concern itself with the event model at all, and the graphics and input/output are all done through the foundation class.
As Java is incorporated into more and more introductory courses, resources for graphics-oriented projects and assignments are beginning to increase. Most of these are available through the web. In this section we list a number of such resources, divided into graphics programming (graphical output as the primary goal of the assignment) and visualization (graphical output used to visualize an underlying data structure of the algorithm).
Already noted, Gordon Stegink [2,26] has developed an entire introductory course employing applet-based graphics programming assignments. He has a large number of projects, ranging from short in-class collaborative and over-night exercises to moderate size projects. One needs to look at his web site to see the broad range of his work, but most introductory language concepts are covered in at least one assignment. Examples are (i) a short assignment on boolean conditions where students color random points based on conditions (for example, color all points above center red, color all points in a defined circle green, and so forth), and (ii) a project where delivery vehicles are navigated through a grid of possibly one-way streets to a series of delivery points.
At Alma College, Myles McNally [2,13] uses image processing as a laboratory theme in his introductory course. Employing RGB images, his laboratories focus on using filters to sharpen and soften images (reinforcing files, two-dimensional arrays), using compression to reduce file size (files, rule-length encoding), and area fill algorithms (files, two-dimensional arrays, recursion, events).
The CS department at Helsinki, Finland has developed a web site (in Finnish) [2,32] that includes all of the course material in HTML format: exercises, examination questions along with answers and comments, students' comments on the course. The course material is based on applications, but it introduces applets at the end of the course. The event model is taught using visual examples. Course material from four courses is available, allowing instructors and students to see how the course has evolved. A book containing the course materials will be published in September 1998.
F. K. H. A. Dehne has a site [2,4] rich with resources for using visualizations to teach early concepts. This site provides both tools and examples for teaching almost all concepts taught in CS2. Each chapter of a typical CS2 course is presented and examples of visualizations for each concept are available. Topics covered in this site include: data structures and algorithms, OO principles and OO design, stacks, queues, linked lists, sequences, trees, priority queues. The course notes of the instructor are available in HTML format as well as in zip files. The site also contains a Java tutorial as well as class libraries and a section on documentation.
Peter Martin's paper [2,14] discusses the features of Java that are significant for teaching CS to undergraduates. Experiences using Java in a first course are presented. The author used turtle graphics and algorithm animation extensively in the class and developed a package of classes to support the instructional units. The support tools for the course, as well as the developed exercises, may be found at the course web site [2,15]. This web site is not mentioned in the paper, but it is filled with examples for teaching almost all of the introductory topics using the graphics and animation classes created for the course.
John Stasko of Georgia Tech has written algorithm animation packages called Tango and Samba that run under both XWindows and MSWindows ([2,23], [2,24], [2,25]). Recently the Samba animation package has been ported to Java. Samba allows students to construct animations of their algorithms by writing a sequence of animation primitives to a text file (called an animation script). Samba then reads the animation script and provides a viewing environment for the animation. Unfortunately, because JSamba is an applet with no access to local files, JSamba must use an awkward workaround to load a net surfer's animation script into JSamba - the animation script must be pasted into the applet's text box.
Tom Naps of Lawrence University has developed a Java Visualizer class ([2,16], [2,17]) that, when instantiated by a student's Java program, creates a graphical snapshot of the state of a data structure that the student's program is manipulating. Naps' Visualizer class is accompanied by a library of standard data structures (vectors, stacks, queues, trees, linked lists, graphs) that students must use when creating visualizations with the Visualizer class. Students may easily augment the methods of the Visualizer class to add color highlights to the data structure snapshots, and, with significantly more work, they may also extend the structure library accompanying the Visualizer class to produce tailor-made drawings of unique data structures.
A web site at the University of Patras [2,5] contains short explanations of advanced level algorithms such as Prim, Kruskal, dynamic programming, and TSP, along with applets visualizing the algorithms. The applets also accept user input, thus allowing the student to experiment with the algorithm.
Jeliot ([2,6], [2,29]) is a algorithm visualization environment that can be used over the web. It also supports visual debugging since it automatically builds an animation of pure Java code. Jeliot animates data types in the program, thus supporting the visualization of elementary data types as well as data structures. In addition, scope of the data types and complexity of the program can be observed. Jeliot can be used as a demonstration tool, or the students can experiment on their own.
Mordechai Ben-Ari[2,1], [2,2] from the Weizman Institute in Israel has been working with visualizing parallel algorithms. Available code includes applets for demonstrating distributed algorithms: Byzantine Generals, Ricart-Agrawala mutual exclusion, Dijkstra-Scholten termination and Lamport-Chandy snapshots.
A set of visualization tools has been created by the Computer Science Department at Virginia Tech [2,35] to help teach statistical concepts in the social sciences. These tools serve as excellent examples of the use of applets in teaching.
Pam Lawhead and Dawn Wilkin's JADE project [2,11] differs from many other algorithm demonstration sites in that it uses Java threads to simultaneously provide the algorithm animation, an explanation of the algorithm, and the code for each algorithm as it runs. The code view is available in Java, Pascal, C and pseudo code. As the animation runs in the animation window the appropriate code lines are highlighted in a separate window. This site could serve as an introduction to data structures and algorithms because it provides in concurrent threads visualization, explanation, and a view of the code.
Susan Rodger's JAWAA [2,20] is a tool for easily generating animations of a user's programs over the web. The user's program can be written in any programming language. The user adds JAWAA commands to the program, generating JAWAA output in a file. An applet then loads JAWAA and the user's JAWAA commands and runs the animation. JAWAA commands consist of simple primitives such as circles, points, lines, and rectangles, and special commands for interacting with data structures such as array, queue, stack, tree, and graph. For example, one can easily illustrate the search for an element in an array by first using one JAWAA command to create an array filled with elements and additional JAWAA commands to change the color of each individual cell touched along the search. JAWAA automatically creates the boxes for the array and the placement of the elements in the boxes.
Rodger has also created JFLAP [2,21], a tool for interacting with several types of automata, including converting one type of language to another. With JFLAP one can create graphical representations of transition diagrams for nondeterministic finite automata (NFA), pushdown automata (PDA), one-tape Turing machines and two-tape Turing machines. After building an automaton, one can step through its execution on input. New features of JFLAP include converting an NFA to DFA, minimizing a DFA, converting an NFA to a regular grammar, converting a PDA to a context-free grammar, and converting different types of grammars to a PDA. In most of these conversions, the user creates the new representation with JFLAP providing some help. Users can opt to display the final result.
Tools to build student exercises are in the site created by Jef Poskazner [2,33]. For instance, input/output, a troubling feature of Java, is simplified by a set of print utilities found at this site. The cryptographic tools found here would provide the instructor with resources to create exercises that encourage students to explore the characteristics of numeric data types. The widget library available at this site provides students with resources for creating graphical user interfaces. The site also contains graphic image processors, applet/application tools, networking tools, and additional wrappers. It is a rich resource for both teachers and students.
A number of layout managers created by Cary Bear are available at [2,34]. The site has several layout managers extending the standard AWT managers. These layout managers include a number of different Grid layouts -- ProportionalLayout for arranging components proportionally and TreeLayout to organize components in a tree structure. The site also includes instructions for building your own layout manager.
A large collection of Java classes by Brian Bush [2,3] includes data structure libraries, a Virtual Reality Modeling Package, a metrics package for measuring properties of Java source code, and a mathematics package for mathematical calculations. The data structure package is not quite as extensive as the JGL (Java Generic Library) [2,36], but the source code for all the packages is available.
In [2,22] Bernie Roehl and others teach at a relatively advanced level how to combine Java and VRML to achieve interactive pages with three-dimensional graphics. It is a useful resource for individuals thinking of creating three-dimensional visualization with VRML. The book includes code samples for instance complete code for a Java-based three-dimensional server. The code examples tend to be Netscape specific. Readers are expected to have good knowledge of Java. Sections teaching basics of VRML are also present.
Any discussion of the fashion in which Java can alter approaches to teaching the introductory curriculum would be incomplete without citing the work of Lynn Stein at MIT. She presents a novel approach to teaching computer science and a very effective use of Java and visualizations in her paper [2,27]. This paper argues for an update of our current notion of computation, with a heavy emphasis on introducing concurrency early in the first course. The on-line course materials she has developed are paradigmatically different from traditional CS1 courses and are filled with exercises and examples designed to enhance the student's understanding of "what computation looks like." The web page [2,28] for her courses based on this approach to teaching computer science is an excellent source of cleverly designed exercises that get the students involved with the concepts by using and building visualizations for each concept. The spirograph exercises are well designed and effective efforts to teach very early programming concepts with visual tools. The site also provides a set of class libraries and tools to support the exercises.
Stein's radical departure from the traditional CS1 curriculum emphasizes some themes that will continually reappear in the next four sections of this paper. That is, many of the features of the Java language, its built-in class libraries, and additional class libraries that are being developed by other educators allow us to introduce not only new topics in the introductory curriculum but also new ways of looking at problem solving. Many of these innovations can be enhanced further by merging them with the graphics and visualization resources we have already described.
The topics of software engineering affect and underlie most other computing disciplines. The use of Java to explore such issues is a growing phenomenon at all stages of a computing curriculum. The pedagogy of such a broad and ubiquitous topic needs careful planning, and is greatly facilitated by helpful resources.
A new software development paradigm is currently taking place in software engineering. The features that define this new paradigm based on current technologies will necessarily foster the following developments:
* Shift from static to dynamic applications
* The creation of reusable software components
* The continued migration from the use of only localized resources to distributed resources
* The migration to interactive applications [3,2]
* The ability to write software once and to use the resulting code across computer systems, operating systems and architectures
* The development of a language robust enough to accommodate the paradigm shift
Although most of these ideas are addressed in other developments, the creation of the Java language enables software developers to achieve these goals using one central development tool.
Many software engineering courses that use Java are described on the web. Some examples include [3,15], [3,18], [3,21], and [3,19]. Schach [3,9] has converted his software engineering text to specifically address some Java issues.
In the remainder of this section, we expand upon the following topics related to the development of object-oriented software:
* Platform independence
* Class design
* Class hierarchy design
* High-level system design techniques
In each section, we explore various pedagogical options, and discuss ways in which Java can be used to exemplify the concepts. Throughout, we identify and describe various resources that may be helpful for the educator in the pursuit of these and related topics.
The idea of writing code only once and reusing it in multiple programs or applications is a concept which appeals to software designers and is the dominant reason for the prosperity and longevity (measured in computer years) of the Java language.
If we examine the rationale behind the development of Java, two goals are abundantly clear:
* Sun Microsystems programmers wanted a mechanism/tool to offer a degree of standardization to computer programming and,
* To design a language which would be totally platform independent. [3,10]
The idea of platform independence is based on the ability to write code only once and be able to subsequently execute this code on any machine. To demonstrate this concept to introductory computer science students, the following assignment might be useful:
* Give students several small programs using a language other than Java.
* Require students to execute the program using two different computer systems.
* Have the students identify which programs executed on which machines
* Give students Java code for the same problems.
* Repeat the second and third steps (JVMs should be present on both computer systems).
Repeat the assignment above with modifications. For instance, given the Java code for a particular program, ask students to code and execute the same program in another language and repeat the steps above. (This is a skill most students will bring to the classroom.)
A demonstration could be done to shed light on a student's understanding of the execution of programs using a preemptive versus non-preemptive operating systems [3, 12]. That is, given a program with multiple threads, have students execute using a non-preemptive operating system such as a Mac and a preemptive system such as Windows 95. Have students explain what accounts for the difference in the execution of the programs using these different operating systems (The program must contain one task that monopolizes the central processing unit).
Such demonstrations should allow them to question whether a platform independent language (namely Java) is truly independent of every component of the system - in this case the operating system.
Although the idea of writing code only once and subsequently using it in any environment is Java's claim to fame. The reality of such a statement is that no such language currently exists. Although we acknowledge that Java has come remarkably close to providing such an environment, these are issues and ideas which students should realistically be made aware of - starting with the requirement of a JVM (Java Virtual Machine) being present on the machine which is expected to execute Java code.
Another platform independence issue which can be readily demonstrated revolves around the design of user interfaces. Because Java displays user interfaces using the characteristics of the host machine, designers often observe differences in the displayed output.
To simplify the creation of graphical user interfaces, Java developers introduced a development tool called Java Beans. These components are simply formalizations of reusable components [3,12]. Sites which contain guidance on the creation of Java graphical user interfaces include:
* Carnegie Mellon University [3,20]
* IBM 
* Inside-Java [3,8]
* Pace University [3,1]
Java makes use of an interpreted model and dynamically linked libraries across wide-area networks. Consequently, it provides an opportunity for students to examine the corresponding efficiency issues.
Although most Java programmers complain of the slow performance problem, Sun Microsystems programmers have slightly different ideas and uses about the dynamic nature of Java. According to these programmers:
"Java was designed for an environment without a linking phase. Each class or interface file is compiled separately, before a program is run. If a class or interface is needed, the appropriate binary file is dynamically loaded into the Java Virtual Machine (JVM) running the program (after appropriate verification). There is not necessarily a single program image, since any unneeded classes on a particular run won't be loaded during that run. On a run when a different environment or interaction is present, those classes may be needed and will get loaded into the JVM for execution then." [3, 13]
Simply stated, one of the major characteristics of Java programming is to allow components to be called as needed, thus eliminating the need to assemble programs into a single binary image as in traditional languages such as C and then loading them as a complete unit. Examining the tradeoffs of such issues should prove to be a worthwhile endeavor of more advanced software engineering students.
There are predictions from compiler theoreticians that Java will soon be viewed as more efficienct than C rather than less [3,7]. Such progress in this area will greatly enhance the ability to use Java for a larger domain of problems.
Because classes are the core element of object-oriented design, students must understand how to determine their nature and content. They must also consider carefully how to protect classes, and the objects they define, from improper use. Class design addresses the essence of modularity, long known to be a key element in software design. It also provides the overall mechanism for encapsulation, the means by which scope is defined for all data and functionality in a software system.
Encapsulation in Java is accomplished through the use of visibility modifiers, defined at four levels (default, public, protected, and private). Teaching the full spectrum of Java encapsulation is challenging for several reasons:
* The differences between the visibilty levels are not intuitive
* Not all visibility modifiers apply to the same set of language constructs
* The differences cannot be fully understood until certain other language topics, such as inheritance and packages, are addressed
Some aspects of encapsulation should be addressed as soon as multiple classes are used to define a program. Therefore the full encapsulation picture becomes an evolving topic, slowly explored as the prerequisite topics are addressed. Whether this coverage extends over multiple courses depends on the content of those courses. In any case, it is likely a good idea to return to the big picture of encapsulation once all pieces are in place. A danger of the widely diverse nature of this coverage is that the complete picture is never formed explicitly in the student's mind.
The complete effect of all visibility modifiers is found at the appropriate points of the Java language specification [3,4]. An appendix in [3,6], a CS1 text, succinctly summarizes the effects of the modifiers, as well as discussing them throughout the text. Symes [3,11] presents an example of a introductory course syllabus with a strong emphasis on class design issues. A book, with an accompanying web-based discussion can be found at [3,17].
The concept of inheritance is the foundation of a class hierarchy, and provides a major software engineering technique used in development. Inheritance allows a design to proceed from a class with general features to its subclass that provides more specific features. The project then incorporates only sufficient detail at each of the level of subclass where it is needed.
The java.awt and java.io packages make extensive use of inheritance and provide an illustration of the technique. An introductory course can thus use these packages for an early discussion of inheritance. For example, when learning the java.awt package, it can be pointed out in a discussion of the various GUI widgets such as buttons, radios, check boxes, menu items that they are various subclasses of panels. Thus, panel provides a general support for labeling and storing values of the widgets and each individual subclass provides the customized interaction with a user as required by the corresponding widget.
In a senior software engineering course, Java provides the framework for incorporating design of the class hierarchy in a course project. As the subclass at each level is designed, it can be checked for the appropriate level of details. When time is limited in a course, a set of superclasses can be provided at the beginning and used as a foundation for students to refine at the level subclass levels. Alternatively, the various levels can be handled by different teams.
An example of the use of class hierarchy is a network programming class at La Sierra University [3,14]. The instructor provides the framework of a minimally working client server program to afford students a quick start into the project. During the first week of class, students will already be able to examine a running project. Their tasks in successive weeks will be to produce subclasses that have greater capabilities and thus extend the original project with additional features.
One of the goals in teaching software engineering is to promote the production of robust software products. A robust product should respond to user errors and other potentially catastrophic situations gracefully, without collapsing abruptly, but instead support the opportunity to recover from errors. A common mechanism that supports this paradigm is the provision for exception handling. If the programming environment supports exceptions, it is possible to specify in advance how certain groups of errors should be handled.
Exception handling is an integral part of Java, and is implemented 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 the likely location for trouble to occur.) This placement tends to encourage the use of exception handling since it tracks the flow of program logic more closely than when an exception handler is developed as an afterthought elsewhere in the program.
The proximity of code to its exception handler leads to a natural introduction of exception handling early in an introductory course. This is further encouraged by Java's required exception handling in many of its fundamental class libraries. For example, all input/output and network related classes require the user to provide exception handling before programs will compile. Consequently, it is easy to point out that exception handling is an integral part of program design. A good tutorial on Java exception handling can be found at [3, 16].
In a software engineering class, it is easy to require students to design and specify all exception handling that may arise since the language supports it readily. Moreover the language provides a feature for a method to include mandatory exception handling, as illustrated by the I/O and network related classes mentioned above.
Because much of the discipline of software engineering relates to the development of large software systems, object-oriented analysis and design approaches contribute to the core pedagogy. Two popular techniques for addressing analysis and design are the Unified Modeling Language (UML) and patterns. Neither of these techniques 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 previously independent modeling advocates: Booch, Rumbaugh, and Jacobson. It has become the de facto standard of object-oriented analysis and design notation. The idea behind patterns is that many programming situations lend themselves to a general approach, which can be identified and abstracted. Software designs can then be thought of as instances of the general patterns.
Many educators agree that the basic ideas of UML and patterns can be introduced at the early stages, such as CS1 and CS2. Certainly, detailed aspects of these topics are best addressed in an advanced course on large-scale software development.
The Rational web site mentioned above, was founded by the UML authors. It allows you to download a time-limited, full featured version of Rational Rose, the CASE tool developed by the UML designers to support object-oriented analysis and design. Another UML/Java editor can be found at [3,24]. An additional introductory level UML tool is under development at Pace University by Bergin [3,1].
A key concept in many general software engineering texts is patterns. This topic is covered in Larman [3,5] and the Sugar project [3, 19].
Our goal is to investigate how Java may be used as a tool for teaching, networking, database, and concurrent and parallel computing. If models for teaching these topics in Java can be developed, this will make it possible to teach them more effectively. Hopefully, this will facilitate the teaching of these topics more broadly throughout 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 addressed in these sections are:
* Multithreading is an integral part of the language
* Standard libraries are provided to facilitate networking
* Standard libraries are provided for accessing SQL-compatible relational database systems are provided with the language
These particular strengths make Java an appealing platform for several computer science subject areas. With built-in support for threads, Java allows early introduction to the use of threads and the resulting issues of concurrency and synchronization. With built-in support for networking, Java allows the students to easily develop applications that communicate over the network and to understand how that communication is done. With built-in support for database connectivity, Java allows the student to examine issues involving databases ranging from simple queries to a single database to complex transactions over a distributed database. On the other hand, while Java does not explicitly support high-performance parallel computing, libraries and tools are being developed in Java for multiprocessors and distributed computers.
Each of these subject areas is addressed in a following section. Concurrent and parallel computing are combined in this section. Networking and database systems are covered in sections 5 and 6 respectively. Each of these sections first addresses how the subject area can be treated in a course early in the computer science curriculum. Each section then addresses treatment of an advanced course.
Having built-in threads makes Java a natural candidate for parallel and concurrent computing. Here we consider some of the strengths and weaknesses of Java as a tool for teaching parallel and concurrent computing. In addition to advantages of Java which have been discussed above, Java has two particular strengths for parallel and concurrent computing -- built-in multithreading and a library of networking classes.
However, one of the key objectives of parallel computing is high performance. Consequently, there are some disadvantages to the use of Java:
* Java is interpreted and therefore is slower than compiled languages
* support for multithreading of a shared memory multiprocessor is platform specific and is just beginning to appear
* multithreading synchronization in Java is surprisingly tricky to use
The following recent comments underscore the importance of the last point:
"Java atomic procedures and lightweight threads can 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 early 1970s (by Dijkstra, Brinch-Hansen, Hoare, and others) as a structured way of using the more primitive notion of semaphores. The standard reference quoted by Sun is [4,13]. Nevertheless, monitors and condition-variables are not easy to use. The semantics are volatile and do not compose...." [4,22]
The first two drawbacks to doing parallel computing in Java are likely to fade as just-in-time compilers become more effective and operating systems facilitate the use of threads on multiprocessors. However, the last point, the difficulty of reliable thread programming in Java, needs to be addressed before Java can become an effective tool for teaching parallel and concurrent programming. Indeed, work on this problem is essential to the effective use of Java for concurrent programming. We are focusing on investigating tools which have been developed to solve this problem and how those tools might be useful for teaching purposes.
Before we explore such tools, we briefly consider some of the salient issues of parallel computing in general and their implications for parallel computing in Java. The most important dichotomy in parallel computing is between the shared memory multiprocessor and the distributed memory, message-passing hardware and programming models. Many developers consider the shared memory model to be easier to program, at least for people initially trained for sequential programming, whereas there are limits on the scalability of the hardware for this model. The message-passing model calls for more work from the programmer in terms of allocating processes and data to processors, but scales to very large numbers of processors, up to several thousand. As the shared memory model is scaled up, the hardware is generally limited to fewer than 100 processors for SMP machines (symmetric multiprocessors) and must move to NUMA machines (non-uniform memory access), thereby raising some of the same issues of data distribution that is important for distributed memory machines. In both models, deadlock and other synchronization issues are very important aspects of program development. Distributed memory machines may have synchronous or asynchronous message protocols, each with its advantages and disadvantages. In either case, there may be significant overheads for message-passing on distributed memory machines, although there have been efforts in the past to develop hardware which reduces this problem (e.g. the transputer).
The object-oriented programming model blurs some of the distinctions between the shared memory and distributed memory models for parallel programming. Calling an object method is conceptually close to sending a message. Consequently, a language such as Java can, perhaps, provide a model for parallel programming which is more amenable to programmers working from an object-oriented background, leaving efficiency issues for language implementation on the underlying hardware. Some of the ways in which an object-oriented approach impacts the organization of parallel threads of execution are the following:
* Calling a method is conceptually equivalent to placing the method's arguments into a message and sending the message to the called method's object
- The calling thread blocks and a new thread is created in the called method's object to execute the method's code
- An already existing thread in the method's object is waiting to receive the message and continues execution when the message arrives
- A thread in the called method's object selects one of several queued messages to receive based on some criterion and that thread executes the method associated with the received message (rendezvous)
- If the calling thread does not block after sending the message, then we have asynchronous rather than synchronous behavior
- If the calling thread's object and the called method's object are on different machines, then we have a remote procedure call.
* A process is like an active object that has one or more threads encapsulated inside it and has its own private data.
We conclude that Java needs an API for concurrent and parallel programming to overcome the problem of low-level synchronization primitives cited above. Such an API should provide
* Design combinations for method invocation / message passing (channels):
asynchronous message passing
synchronous message passing
remote procedure call
* One Java virtual machine executes on a shared-memory multiprocessor or in DSM (distributed shared memory) on a distributed memory multicomputer, transparent to the programmer
* The supporting underlying OS implements the channels 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 made toward developing an API which implements a message passing paradigm for Java concurrent and parallel computing, JCSP (Java with CSP -- Communicating Sequential Processes). JCSP is under development at the University of Kent, UK, under the leadership of Peter Welch. A parallel effort called JavaPP is underway at the University of Twente, Netherlands, under the leadership of Andre Bakkers and Gerald Hilderink.
The development of a library of classes which provide a CSP style of message passing provides the tools needed to do more reliable concurrent programming in Java and to be able to teach concurrent and parallel programming in Java effectively. This model is based on the theoretical language CSP [4,12]. CSP found its first major implementation in Occam 2, the language developed for parallel computing in conjunction with the transputer, a processor developed in the mid-1980s for embedded and parallel computing. The two versions of Java with CSP mentioned above provide free libraries which implement CSP-style message-passing using channels. Channels are intermediate objects between threads that will free the programmer from synchronization, scheduling and data transfer constructs. Channels are easy to use and one can easily reason about the program. The composition constructs provide sequential, parallel, and alternative reading/writing on a channel. These constructs can be used to avoid deadlock and free the programmer from low-level synchronization and scheduling constructs, such as monitors and semaphores. This way, a Java program can be well-structured and well-behaved. The library is written in 100% Java. Link drivers for connections over the internet have been developed, so that channels can be used to communicate between processes on different machines. Information and the free libraries for the two versions of Java with CSP can be found at the URLs [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 Windows 95 and found that it works well (note -- a patch to the just-in-time compiler for JDK 1.1.6 must be installed, or else run without the JIT). Over the coming months we expect these two teams to merge their efforts into one common platform.
The development of Java with CSP does not, however, solve the problem of explicitly assigning different threads to different processors for true parallel computing. At some point, the operating systems for multiprocessors should catch up and make such assignment automatic. It would also be useful if control over the assignment of threads to different processors could be under programmer control. For now, it is possible to get access to thread control on multiple processors by using Sun Microsystems JDK 1.2 for Solaris 2.6, [4,20]. This JDK has an interface to the native Solaris multithreading library and allows the applications programmer to set the number of physical CPUs over which the Java threads will be distributed. However, this approach in itself does nothing to hide the complexities and subtleties of Java monitors from the programmer. It may be possible to combine 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 with Java include implementations for PVM and MPI. These are discussed below in the context of advanced courses.
An introductory course which uses Java can reasonably include an introduction to concurrent and parallel computing. However, doing complex concurrent programs using the Java supplied primitives for synchronization rapidly becomes overly complex. Consequently, we recommend that at the introductory level, an introduction to concurrent and parallel programs be based on the simplest constructs in Java, namely join(), or be based on a tool such as Java with CSP, as described above.
In the first instance, simple parallel programs can be constructed by having a main thread start several concurrent threads, then wait for them to terminate by using the join() method. In this way, parallel code with simple barrier synchronization can be introduced. However, critical sections needed for concurrent write access to memory would still depend on the complexities of Java monitors [4,8], which are better avoided at this level. Instructor supplied applets are useful in introductory CS courses to demonstrate deadlock and race conditions.
If one is ready to devote a larger portion of the course to parallel and concurrent computing, then Java with CSP tools provide a good alternative. The channel communications combined with parallel and selection based control of communications provides a mechanism for concurrency which is straightforward and robust. The Java with CSP tools include CSP channel-based version of the Java AWT interfaces, making it easy to build graphical interfaces which mesh with the Java with CSP code. The University of Kent, U.K., has used this approach successfully with Occam 2, teaching concurrent and parallel computing to first year students. They plan to change to Java in the near future, using the Java with CSP tools [4,23] [4,24].
Lynn Stein at MIT has proposed an approach similar to the Kent approach for teaching introductory programming. Here, using Java, interacting concurrent threads comprise the fundamental model. Extensive materials describing this approach are available at the web site [4,19] and the case is made for this approach in Stein's paper [4,18].
Java provides the opportunity for studying concurrent and parallel constructs in some detail in higher level courses. The courses most likely to use these facilities are an Operating Systems or Systems Programming course and a course on Parallel Computing or a course which makes use of parallel computing such as Computational Science or an Algorithms course which includes an emphasis on parallel algorithms. We discuss these alternatives under the headings of Operating Systems and Parallel and High Performance Computing.
The primitive tools provided for concurrent control in Java (the monitor methods wait(), notify(), and notifyAll()) are the basis for studying low-level concurrency control in an OS course. The proper use of these constructs can be followed by the study of the difficulties which they raise, the ease with which deadlock and race conditions can inadvertently be included in your code, especially in the context of programs whose threads might be interrupted with the interrupt() method. This leads naturally to a discussion for the need for a better type of abstraction for concurrent control, such as those provided by the Java with CSP tools.
A second OS topic which can be raised in the context of Java is the scheduling of concurrent threads. The Java thread scheduler, and its relationship to the OS scheduler, can be used as a case study. Issues of time-slicing for concurrency, priority, and their dependence on the underlying operating system can be studied in this context. Since Java does not provide a platform-independent scheduler, but relies on the underlying operating system, this leads to issues of the implementation of Java itself.
There are several sources on the web about Operating Systems courses that use Java. McCauley [4,16] has a web site with links to many of these sources, as will the web site developed in conjunction with this paper [1,4]. The texts by Lea [4,14] and Hartley [4,9] contain much of the fundamental material on concurrency control which would be used in an O.S. course.
The inclusion of threads in Java provides the opportunity for doing parallel computing on a symmetric multiprocessor (SMP) or on a network of workstations. The primitive control structures provided in Java are not appropriate for this type of computing, so an additional set of tools must be used.
The Java with CSP tools described above provide a message-passing paradigm which can be used both on SMPs and on a network of workstations. The lack of explicit control of the scheduling of threads is currently a disadvantage of using the Java with CSP tools. However, a concurrent program with reasonable slack in the parallelism (many more parallel threads than processors) should run well on an SMP if the underlying OS schedules threads across the processors. Link drivers which provide for machine to machine connections mapped to CSP channels are under development by the groups at the Universities of Kent and Twente. These will provide the tools needed for developing message-passing parallel programs which can run on a network of workstations.
One advantage of the use of Java with CSP is that the semantics of the language are compositional: control constructs can be understood locally and components can be composed to construct larger components with well-defined and provably correct behavior.
Caromel and Vayssiere have developed a library for Parallel, Distributed, and Concurrent Computing, Proactive PDC [4,2] [4,3]. This library provides facilities for working with objects distributed among a network of machines cooperating on a parallel or concurrent computation.
Other groups have been developing tools for parallel computing in a Java environment based on tools previously developed for C or FORTRAN: MPI (Message Passing Interface) and PVM (Parallel Virtual Machine). Both MPI and PVM provide libraries for message-passing parallel computing for C and FORTRAN which can be used on networks of workstations for several different operating systems.
A project at the Georgia Tech Institute for Systems Engineering under the direction of Christine Mitchell has developed a Java interface to PVM. The C-based PVM functions do the work, but the Java library provides Java interfaces to this library, so that the main code can be written in Java. A on-line version of the system is available [4,17].
Two projects are underway to provide a Java interface for MPI, the more recently developed standard for message-passing parallel programs. The Institute for Systems Programming in Rumania, with M. Domrachev, V. Etch, S. Gaissaryan, V. Ivannikov, and N. Shtaltovnaya, is developing "Data Parallel Java," a library of Java wrappers 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 by George Crawford at MPI Software Technology, Inc. under a U.S. Department of Energy grant "Integrated MPI and Java 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 Programming Project, led by John Thornton and K. Mani Chandy provides facilities for doing shared memory parallel computing in an environment which supports threads. This library has been developed for use with p-threads in UNIX or with Windows NT threads [4,21].
At this time the Java with CSP tools and the Georgia Tech Java-PVM projects provide tools which can be downloaded and used. The other projects are under development and may provide useful tools for parallel computing in the future.
Few materials, such as web sites, are available to help instructors with teaching students how to use the new tools that are being developed. Watch the web site associated with this report, where links will be placed to useful sites as they are discovered [1,4].
In this section, our goal is to investigate how Java may be used 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 more effectively. Hopefully, this will also facilitate the teaching of networking more broadly throughout the computer science curriculum.
Two particular strengths of Java for the topic addressed in this section are:
* multi-threading is an integral part of the language
* libraries are included to develop network-based software at several levels
These particular strengths make Java an appealing platform for teaching computer networks. Java allows the students to easily develop applications that communicate over the network and to understand how that communication is done. This section first addresses how the subject area can be treated in a course early in the computer science curriculum. This section then addresses treatment within an advanced course.
The initial development of Java included libraries for network programming. Consequently, writing programs involving network access is unusually straightforward. Early in their course, introductory students can write programs that use the network in a simple fashion. Later they can develop programs that access the network in a non-trivial manner.
The natural first introduction to networking is through the development and use of a Java applet. By the applet being embedded in an HTML document and the student calling the applet through a web browser, the student automatically is using the network as the applet is retrieved from the web server. The level of explanation of how the network is being used is not difficult. In fact, some CS1 textbooks ([5,2], [5,14], [5,15]) introduce applets in the first few chapters. Interesting uses of applets often involve graphical programming (and the AWT package) so other CS1 authors [5,1][5,8] have chosen to delay introducing applets until after much of the basic machinery of the language has been covered.
After an initial introduction to applets, the networking aspects of Java can be extended through applets. The java.applet package contains the Applet class and the three interfaces AppletContext, AppletStub, and AudioClip. The URL class in the java.net package is used to construct and inspect URLs. It should still be possible near the end of CS1 to have students write applets that use methods from the java.applet package and the URL class. For example, an applet can be written [5,1][5,2] that constructs the URL of a file that contains an image or an audio clip, downloads that file, and displays the image or plays the audio clip.
Java can also be used in another manner that is appropriate within CS1, especially a CS1 that is breadth-oriented. Java can be used as a tool for learning networking concepts, instead of as a tool for learning networking programming. One such approach is to use Java applets that are interactive simulations that introduce a networking concept. For example, Holliday [5,6] has developed three relevant applets. One applet illustrates encapsulation as a packet moves through the protocol layers on the source host, intermediate routers, and destination host. A second applet illustrates the media access protocol used by Ethernet. A third applet illustrates error recovery mechanisms suitable for the transport layer. These applets were designed for the non-major course but could also be used in courses within the major.
A second approach is to use programs written in Java for live protocol demonstrations. For example Harold [5,5] has written two simple Java programs, javalookup and clientTester that can be used in assignments [5,6]. Javalookup is similar to the nslookup utility and can be used to demonstrate domain name resolution; the student can convert between an internet domain name and an IP address. ClientTester listens on a TCP port and displays to standard output any messages received. ClientTester, telnet, a web browser, and a web server can be used to illustrate the messages sent by HTTP during a web page access. In a later course the student can study the code of these programs instead of just using them.
Just as Java triggers changes in CS1 by the inclusion of some networking features, Java also triggers changes in a networking course aimed at the junior/senior level. One of the significant achievements of Java is dramatically simplifying socket programming (that is, programming at the level of TCP and UDP). In fact Java socket programming is even included in some CS1 textbooks [5,1]. Socket programming in C or C++ is more complex and tedious with no additional gain in understanding. Another achievement is how well Java supports web programming both client-side and server-side. Finally, Java's RMI (Remote Method Invocation) is a natural way to introduce distributed object-level programming.
Paul Tymann's slides [5,21] from his Introduction to Java Networking tutorial at SIGCSE'98 are an excellent introduction to network programming using Java. The Java Tutorial maintained by Javasoft [5,9] is an in-depth coverage of most of the Java language features including the networking features. The version of the Java Tutorial that is maintained on the web is continually being updated. The Operating Systems, Parallel Computing, and Networks section of Renee McCauley's Computer Science Education Links page [5,17] has some networking links that are relevant. The web page for the Computer Networks textbook by Peterson and Davie [5,19] has a link to socket programming assignments that have been developed by a number of instructors. These assignments have not, in general, been developed using Java, but could easily be adapted to a networking course that uses Java.
Though Harold's Java Network Programming [5,5] was not written as a textbook, his ordering of programming topics can be effective in a networks course as described in the rest of this section. The code for all the examples in Harold (and some of the other books mentioned below) is available on the web. Before encountering socket programming, interesting assignments [5,7] (such as the javalookup program mentioned above) are possible using some of the simpler classes in the java.net package, InetAddress, URL, and URLEncoder. Socket programming can start with TCP clients using the Socket class and TCP servers using the ServerSocket class. The clientTester program mentioned above is one example of using the ServerSocket class; simple HTTP and proxy servers are other examples [5,5][5,4][5,10]. If the students have not seen Java threads before, threads will need to be introduced as TCP servers are covered [5,3]. Using one thread to listen for new connections and a new thread to service each connection is a very common TCP server design feature.
Once the students are comfortable with TCP programming, the two UDP classes, DatagramPacket and DatagramSocket, can be introduced for both clients and servers [5,5][5,10]. For example, Holliday [5,7] developed two assignments. In the first assignment the students implemented a chat client and a multithreaded chat server (with synchronized access to the shared log of messages) using the TCP classes. In the second assignment the students re-implemented the chat client and server using the UDP classes. The MulticastSocket class is a subclass of the DatagramSocket class. It can be covered after unicast UDP programming to illustrate the performance advantages of multicasting in some situations.
After socket programming, the three main remaining features of Java networking support that should be covered are security and cryptography, servlets, and RMI (Remote Method Invocation). The instructor can show how the java.security package can be used to add a security manager to a network server and to generate message digests and digital signatures, manage access control lists, and perform simple key management. David Flanagan's Java Examples in a Nutshell [5,4] and Farley's Java Distributed Computing [5,3] have chapters illustrating using this package. The Java Tutorial has subtutorials on security in both JDK 1.1 [5,12] and in JDK 1.2 [5,13].
A servlet is a class written by the programmer to implement the Servlet interface of the java.servlet package. They, like CGI programs, are a way for a web server to dynamically generate data (such as HTML) to be sent to a client. For example, the server-side include mechanism can be used to embed a servlet in an HTML page. Servlets are a useful example that the instructor can present as an alternative to CGI scripts and Microsoft Active Server Pages [5,5][5,11].
A major step is to show students that larger and more robust distributed applications should be built at a higher level of abstraction than the socket level. In particular, the application should be composed as a collection of cooperating and coordinating objects. Remote Method Invocation (RMI) is a natural first method of programming at this level to show the students since RMI is relatively simple and designed specifically for a Java programming environment. RMI is implemented by the java.rmi package. Explaining RMI motivates the need for object serialization in order to marshall and unmarshall the arguments for a method invocation to a remote object machine. A number of relatively large RMI-based distributed applications are available in the literature and have 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 chat system and a shared whiteboard. Reese [5,20] has a distributed database system example based on RMI.
Once RMI is understood by the students, the instructor can introduce RPC (Remote Procedure Call) as an earlier abstraction for distributed programming above the socket level. RMI is both a distributed object model and a particular protocol, RMP (Remote Method Protocol) for implementing the communication between objects. The alternative distributed object models provided by CORBA (Common Object Request Broker Architecture), and Microsoft's DCOM (Distributed Common Object Model) can be compared with the RMI object model. CORBA's IIOP (Internet Inter-ORB Protocol) can be compared with RMP. Recent developments in the support of RMI within CORBA through RMI-over-IIOP (instead of over RMP) can be discussed.
When distributed object models are understood the instructor can introduce the distinction between two-tier and three-tier distributed applications. As a final step, JavaBeans and Enterprise JavaBeans can be addressed. JavaBeans, supported by the java.beans package, is a component model. Any Java class that conforms to the JavaBeans specification is a bean or component. Building an object as a component (bean) helps to ensure that the object can be more easily used in building a large application. For example, the JavaBeans specification provides support for creating components that have persistence and introspection. A persistent component knows how to store its state when it is deactivated and how to restore its state when it is reactivated. An introspective component can be assembled with other components into an application using a visual assembly tool even if the component itself is not visible when it executes.
The Enterprise JavaBeans (EJB) API defines a server-side component model extension of JavaBeans as well as a framework for server-side component coordinators. Some have called the new class of component coordinators OTMs (Object Transition Monitors). A key feature of an EJB-compliant OTM is support for distributed flat transactions modeled after the CORBA Object Transaction Server (OTS) specification. The EJB specification, the java.ejb package, was carefully designed to be compatible with CORBA. In fact, since CORBA does not include a framework for server-side component coordinators, EJB complements CORBA. Orfali and Harley [5,18] provide a detailed discussion of RMI, CORBA, DCOM, Enterprise Java Beans and their use in multi-tier architectures. A web site at Los Alamos National Laboratories [5,16] has an extensive collection of links related to distributed object models with an emphasis on CORBA.
The initial release of Java (Java 1.0) provided only the basic level of functionality needed to develop applets and applications. Later releases (Java 1.1 and 1.2) saw this basic functionality grow beyond the core API to include other APIs as well. One of these APIs, the Java DataBase Connectivity API, or JDBC, provides database connectivity support allowing programmers to access databases on the internet and to send SQL commands to these databases as arguments to methods of the JDBC interfaces. The JDBC API is available in the java.sql package, which is included in JDK distribution.
By providing this level of support, Java makes it possible for students at all levels, from introductory to advanced, to work with databases in their programs. At the introductory level it maybe merely to use the database as a source of data in the simplest of client-server models; at the advanced level their use may be included as part of a multi-tiered distributed database architecture.
Late in a CS1 course or in a CS2 course, databases can be introduced as the last phase in a natural progression for program input. The progression will usually begin with input entered by a user, move on to input streams, and now turns to databases accessible via a network as another source. In addition, instead of merely being a source for unprocessed data as is the case with user-supplied input or data from an input stream, the data made available via the database comes as a result of a database query. This affords the student a first glance at a client-server architecture.
At any level, exposing students to databases with Java and JDBC requires that, on the database side, they know something about (relational) database concepts and SQL. On the Java side they must use URLs, database drivers, and the JDBC classes and interfaces. Fortunately the depth of knowledge required in all of these can be sufficiently scaled down to make it feasible to use them at an introductory level.
With respect to database concepts, a student can manage quite easily knowing only the fundamental structures of relational databases -- relations/tables, tuples/records, and fields (with their associated names and types). Likewise only the simplest form of SQL's SELECT command needs to be furnished, although including the WHERE clause would help provide the front-end processing whose use would take us to a client-server model. The introduction to SQL on pages 13-17 of Reese [6,16], for example is more than sufficient for this purpose.
As for Java, using the JDBC classes, interfaces, and methods would become just one more learning experience in what is becoming a familiar pattern to the student. We point out here a few ideas for scaling down some of the concepts that might be troublesome to introductory-level students.
For network connectivity, if the introduction of JDBC follows an introduction to networking, the student would already be familiar with URLs. However, Java avoids the networking background problem because one does not need to know anything about the URL class in order to access a remote database through JDBC. The URL is supplied as a String argument to the getConnection() method of the DriverManager class. To assist introductory level students the instructor can supply an example of such an argument and the students can use it as a model that can be adapted to a specific database reference. The only portion of the URL that might puzzle the student is the reference to the driver subprotocol that precedes the database location. This can be explained, however, as one of those things that has to be present in order to connect to the database. The following references deal with Java programming and JDBC, providing suitable examples for specifying database URLs: [6,4] - [6,7], [6,9], [6,10] -[6,16].
The situation with database drivers is similar to that of URLs. Once again, it is unnecessary for the students to acquire a detailed knowledge of what such drivers are and the various classes of drivers used in JDBC. The references provide suitable background material on drivers for those who want more details. For the instructor, getting a database set up and having the correct drivers available for accessing the database requires some attention. Sources such as Chapter 16 of Flanagan's book [6,6] and Chapter 2 of Hamilton, Cattel and Fisher's book [6,7] should be helpful here. All JDBC applications require that one register a Driver class with the DriverManager. Since the easiest way to register a driver is with the Class.forName() method invocation, which takes the driver designation as a String argument, the instructor can provide a driver designation for each database to be used and then rely on the student's inductive abilities to modify them appropriately. It should be noted that the availability of JDBC drivers for a number of database management systems is still relatively limited. Even those that are available may impose limitations on what can be done with a given database. Kingsley Idehen [6,10] points out some of the advantages and disadvantages of the various types of drivers (including the restrictions some impose).
Once a database connection has been made, and this exercise can be the first part of a multi-part assignment or a short assignment in its own right, a simple SELECT command can be sent to the database as a String argument using the executeQuery() method of a Statement object. The results are then collected in a ResultSet object and processed iteratively. Orfali and Harkey [6,15] provide a scenario (but no code) for such a transaction. Other authors, for example [6,6], [6,7], [6,9], or [6,16], provide code. After the iterating completes we need no further use of JDBC except for closing the database. Depending on the depth to which user interfaces have been covered, output can be delivered to standard output or presented more graphically using classes from the AWT.
As a final note, while our discussion has focused on scaling down JDBC and database concepts for introductory level students, other options are possible. For example, the instructor may develop a class library, or even have the students run a pre-built applet that generates most of the syntax for students automatically by having the student fill in a form. In the latter case, if desired the resulting JDBC code and SQL can be executed as well as shown.
The likely target for the use of Java and JDBC at the upper level is in a database course. We shall assume the student has already done some programming in Java and that SQL will be covered in the course, or otherwise learned by the student.
In this section we focus on providing a sequence of progressively more sophisticated exercises that could be phased in over a database course as time and the interest of the instructor allows. Mark Holliday has available on-line [6,8] two handouts describing one such exercise that he uses in a database course.
Although we shall not venture into object-oriented databases here, Barrett R. Bryant [6, 2] has available on-line, a module "Java as an OODB Programming Language" that shows how Java may be used as a programming language for studying object-oriented databases. It is designed to complement the discussion of object-oriented databases given in Ullman's book [6,20].
We now describe one sequence of exercises that we feel can be useful for students:
1. The student can begin with an exercise similar to that described in section 6.2 for the introductory level student -- access an existing database and execute a simple SQL query. This exercise could either serve as a review for those who have already worked with JDBC, or be an introductory exercise for new JDBC users.
2. As a follow-up to the exercise above, the student can write a program to modify a database relation/table via the executeUpdate() method available to Statement objects. Once again, any of the references, [6,4] - [6,7], [6,9], [6,10] - [6,16], provide examples. Once this has been done successfully the instructor may wish to pursue some topics that generalize or optimize the students work thus far:
* Use the execute() method with an arbitrary SQL command as an argument rather than relying on the more restrictive executeQuery() and executeUpdate() methods. This allows the student to specify the type of database transaction to be performed dynamically rather than statically.
* Use prepared statements and stored procedures to show how the run-time efficiency of some database transactions can be improved. Once again most of the textbook and tutorial references cover prepared statements and stored procedures. Reese [6,16] gives an example where code involving SQL calls is re-done using stored procedures.
* Use the classes DatabaseMetaData and ResultSetMetaData to allow a program to retrieve dynamically information about a database's structure or a result set's make-up. This provides more flexibility than having the database's relation names and each relation's field properties embedded in the code. All of the references ([6,4] - [6,7], [6,9], [6,10] -[6,16]) discuss the "meta classes."
3. Building on the foundation established above, once students have successfully embedded SQL commands in a program and connected to a database, it is a simple step to move this code to the run() method for a thread. This lets multiple threads access a database. By varying the ways in which the threads are synchronized to access the database one can explore concurrency and transaction management problems for databases. Issues of transaction management for single database systems are described in Ullman [6,20].
4. As a natural follow-up to the previous exercise, instead of accessing a single database, a thread can read from two or more databases, providing an introduction to issues related to distributed databases, especially issues surrounding the distribution of data among sites and data redundancy among these sites. An introduction to distributed databases can be found in Ceri and Pelagatti [6,3]. This exercise should be restricted to performing only reads on the database in order to avoid more complex transaction management issues.
5. In the previous item we simply had the students read from a distributed database. For this case it does not matter if the records retrieved from each database had common fields, as long as we are assured that data consistency exists for these records. A more ambitious exercise asks students to perform multiple concurrent transactions on a distributed database that involve intermixed reads and writes. This now requires the student to explore issues of data consistency, multi-phase locking protocols, and multi-phase commit schemes and rollbacks. These concepts are discussed in Ceri and Pelagatti [6,3] and Ullman [6,20].
For the instructor who is looking for more extensive models of the use of JDBC, many of the Java programming books that emphasize databases and JDBC ([6,7], [6,9], [6,11], [6,15], and [6,16]) develop a client-server application, such as a server for a bank, that fully exercises JDBC. David Flanagan [6,6] also provides such an example in chapter 16 of his book. Even more extensive examples exist for those who want to venture beyond the two-tier, client-server models we have been using here and to delve into three-tier models. The three-tier architecture uses a middle level that comes between the client system and the distributed data stores to insulate the details of the data distribution from the clients. The middleware makes the data of the database available in the form of remote objects whose data values are mapped to an appropriate data store by the middleware. This allows the clients to work with data in the form Java supports most naturally, namely objects. Accessing remote objects is beyond the capabilities of JDBC. Conveniently, Java has the Remote Method Invocation (RMI) API available for this purpose in the java.rmi package. Examples of three-tier models developed using RMI can be found in Orfali and Harkey [6,15] and in Reese [6,16].
There are a number of other courses in which Java can be used effectively. Many of the resources referenced here are also useful in other courses.
Java has been effectively used in compiler development. The lack of pointers and the subscript bounds checking provided by the language prevent a large number of student errors. Bergin noticed a general increase in the level of quality of completed projects and an increase in the number of successful completions when Java replaced C++ in this course. Three course outlines for the compiler implementation course follow:
* Appel: [7,1] This course is very complete with an associated book by Andrew Appel. It uses tools, similar to lex and yacc, written in Java and available over the web.
* Bergin: [7,2] This is a much simpler course that uses LL(1) parser tools and develops a compiler feature by feature rather than pass by pass.
* Budd: [7,3] This course is also lex and yacc based. The site includes on-line lecture notes, source code and a complete set of assignments.
In some ways Java is ideal for exploring HCI issues. The built-in libraries facilitate graphical interface development and so various interface designs can be explored with little difficulty. However, this assumes that only standard elements will be used. Harder but not impossible is the exploration of non-standard elements such as pie shaped menus.
* Terry Harpold [7,4] at Georgia Tech maintains a page of resources for multimedia designers. Some of this is related to HCI and some to Java
* N. Hari Narayanan [7,5] has a course on HCI. It contains many projects. Some of them are Java specific
* Pacific Bell [7,6] maintains a page of GUI toolkit resources. Some are HCI related and some Java related.
A capstone course can be either an integrated project-based course or a seminar-based course. Such a course can utilize many of the resources mentioned elsewhere in this paper. In particular, such a course can require concurrent programming, database programming, internet programming, or combinations of these. The course can also incorporate human computer interaction issues and graphical interface design. Finally, such a course can emphasize good object-oriented analysis and design. All of these are facilitated by use of Java. An example of such a project based advanced course can be found at Pace University [8,2]. This site contains pointers to a large number of OO and Java resources, including tutorials and tools.
* Kalamazoo College requires a capstone senior project of all students. Information on these requirements can be found at [8,3].
* The University of Durham requires a final year project of most information technology majors. This is described in [8,1]. The course description can be found at [8,4]
* Kris Powers describes a course in Parallel Computing as a Capstone Experience in [8,5]. This is not Java specific, but the ideas may be adapted to Java using resources mentioned elsewhere in this report.
* Ronald Dattero teaches a projects course emphasizing Systems Development in Java. The course page can be found at [8,6]. A few different projects are suggested here, as well as a syllabus. The site also points to a number of useful resources.
We found Java to be 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 new and revised courses. The language itself facilitates this process of course preparation and delivery by providing tools that can be used to build artifacts that illustrate the key ideas of computing. These artifacts can be designed in a way that can be used, examined, extended, and emulated by students.
Java makes accessible early in the curriculum some topics that have traditionally been considered very difficult for novices. Early introduction of such topics can lead to more breadth in the early courses, giving students a better view of the profession, without necessarily sacrificing rigor or depth. This approach, however, requires the instructor to prepare materials in advance and carefully think about their impact. Viera Proulx of Northeastern University has observed that in literature courses we ask the students to examine artifacts that are much more sophisticated than they could themselves produce. She suggests that we can do the same in the computing sciences if we have excellent resources. It has been the intent of the authors of this report to ease the preparation of such resources and to facilitate their sharing.
This report represents an initial step in an ongoing process undertaken by its authors. A copy of this report will be maintained and updated on the web at http://sol.pace.edu/iticse98 . As additional materials and tools become known to the authors, they will be added to the site.
Our thanks to ACM, SIGCSE, SIGCUE, ITiCSE98, the Centre for the Teaching of Computing at Dublin City University and the Computers in Teaching Initiative Centre for Computing (CTI) at the University of Ulster for providing facilities and help in the preparation of this report.
The workgroup co-chairs, Bergin and Naps, would especially like to thank the members of the group for their work in the preparation of this report and their patience with the chairs throughout the process.
[1,1] Biddle, Robert and Ewan Tempero, 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 Southeast Conference (Murfreesboro, Tenn., April, 1997).
[1,3] Tyma, Paul, Why Are We Using Java Again, in Communications of the ACM (June, 1998).
[2,1] Ben-Ari, M. Distributed algorithms in Java. in Proceedings of ITiCSE97 (Uppsala, Sweden, June 1997) 62-64.
[2,2] Ben-Ari, M. Concurrent Programming page: http://stwi.weizmann.ac.il/g-cs/benari/cp.htm
[2,3] Bush, B. Banda Packages: http://www.sladen.com/Java
[2,4] Dehne, F. K. H. A. http://www.scs.carleton.ca/~dehne/tools/java
[2,5] Drossos, N., Papagelis, A., and Papaioannou, P. http://students.ceid.upatras.gr/~papagel/project/contents.htm
[2,6] J. Haajanen, M. Pesonius, E. Sutinen, J. Tarhio, T. Teräsvirta, P. Vanninen: Animation of user algorithms 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 Java Essentials. Wiley, New York, 1997.
[2,8] Kluit, P.G., Sint, M., and Wester, F. Visual Programming with Java: Evaluation of an Introductory Programming Course. In proceedings of ITiCSE98, (Dublin, Ireland, August 1998), 143-147.
[2,9] Kluit, P.G., Sint, M., and Wester, F. Visual programming with Java; an alternative approach to introductory programming in proceedings of ITiCSE 97 (Uppsala, Sweden, June 1997) 57-58.
[2,10] Kluit, Sint, and Wester websites: http://www.ouh.nl
[2,11] Lawhead, P. and Wilkins, D. http://eliot.cs.olemiss.edu/jade
[2,12] Lea, D: http://g.oswego.edu/dl/html/javaINCS.html
[2,13] McNally, M. Using Image Processing as a Laboratory Theme in CS1 and CS2. to appear in the Journal of Computing In Small Colleges, see also http://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, http://www/csm/uwe/ac/uk/~pcmarti/javacourse/javacourse.html
[2,16] Naps, T. L. A Java Visualizer Class: Incorporating Algorithm Visualizations into Students Programs. In Proceedings of ITiCSE98 (Dublin, Ireland, August 1998), 181-184.
[2,17] Naps, T. L. A. WebGAIGS page http://gaigs.cmsc.lawrence.edu
[2,18] Proulx, V. Recursion and Grammars for CS2. in Proceedings of ITiCSE98, (Uppsala, Sweden, June, 1997).
[2,19] Roberts, E., and Picard, A. Designing a Java Graphics Library for CS1. In Proceedings of ITiCSE98 (Dublin, Ireland, August 1998), 215-218.
[2,20] Rodger, S. http://www.cs.duke.edu/~rodgers/tools/tools.html
[2,21] Rodger, S. JFLAP http://www.cs.duke.edu/~magda/flap/index.html
[2,22] Roehl, Bernie et al. Late Night Vrml 2.0 With Java. Ziff Davis Pr; ISBN: 1562765043, 1997.
[2,23] Stasko, J. Tango: A Framework and System for Algorithm Animation; IEEE Computer, September, 1990.
[2,24] Stasko, J. Using Student-Built Algorithm Animations as Learning Aids. In Proceedings of the SIGCSE Session, ACM Meetings (San Jose, CA., February, 1997).
[2,25] Stasko, J. Software visualization at the GVU. http://www.cc.gatech.edu/gvu/softviz
[2,26] Stegink, G. http://www.cs.hope.edu/csci120
[2,27] Stein, L. Reconceptualizing Computation: Radically Rethinking CS1. http://www.ai.mit.edu/people/las/papers/cs101-proposal.html
[2,28] Stein, L. http://www-cs101.ai.mit.edu
[2,29] Sutinen, E., Tarhio, J., and Teräsvirta, T. http://www.cs.helsinki.fi/research/aaps/Jeliot
[2,30] Tyma, Paul: Why are we using Java again?, CACM June 1998, 41,6 pp38-41
[2,31] Weiss, M. A.: Experiences teaching data structures with Java. SIGCSE Bulletin vol. 29, no. 1, 164-168.
[2,32] Wikla, A: http://www.cs.helsinki.fi/~wikla/JohdOhj
[3, 1] Bergin, Joseph, http://csis.pace.edu/~bergin
[3, 2] Boroni, Christopher M., Frances W. Goosey, Michael T. Grinder, Rockford J. Ross, "A Paradigm Shift! The Internet, the Web, Browsers, Java and The Future of Computer Science education", Proceedings of the Twenty-Eighth SIGCSE Technical Symposium on Computer Science Education, 1997, p.145.
[3, 3] Gamma, Helm, Johnson, and Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1995.
[3, 4] Gosling, Joy, Steele, The Java Language Specification, Sun Microsystems, 1998.
[3, 5] Larman, Gary, Applying UML and Patterns, Prentice-Hall, 1997.
[3, 6] Lewis, John and William Loftus, Java Software Solutions: Foundations of Program Design, Addison-Wesley, 1998.
[3, 7] Moss, Elliot, invited talk at OOPSLA 97, Atlanta, Georgia.
[3, 8] Reilly, David, http://www.inside-Java.com/articles/uidesign
[3, 9] Schach, Stephen, Software Engineering with Java, Irwin, 1998
[3, 10] Singhal, Sandeep, and Binh Nguyen, "The Java Factor," Communications of the ACM, June 1998, Vol. 41, No. 6, p. 34.
[3, 11] Symes, Kare, http://www.sm.luth.se/csee/courses
[3, 12] Tyma, Paul, "Why are we using Java again?" Communications of the ACM, June 1998, Vol. 41, No. 6, p. 38.
[3, 13] Waldo, Jim, "Dynamic Lingo," UNIX Reviews Performance Computing, July 98, Vol. 16, Issue 8, p. 25.
[3, 14] http://cs.lasierra.edu/~netprogram
[3, 15] http://edlab-www.cs.umass.edu/~lerner
[3, 16] http://java.sun.com/docs/books/tutorial/essential/exceptions
[3, 17] http://www.artima.com/flexiblejava
[3, 18] http://www.caip.rutgers.edu/~marsic/Teaching/14:332:472.html
[3, 19] http://www.dcs.napier.ac.uk/~ooseb
[3, 20] http://www.heinz.cmu.edu/project/java/labs/lab4/lab4.html
[3, 21] http://www.math.luc.edu/~laufer/courses/473
[3, 22] http://www.rational.com
[3, 23] http://www.redbooks.ibm.com/SG242232/javac10.html
[3, 24] http://www2.ai-lab.fh-furtwangen.de/~bless/UMLEditor/index.html
[4,1] Austin, Paul, JCSP web page. . Online, Internet. Accessed 19 August, 1998. Available http://www.cs.ukc.ac.uk/projects/ofa/jcsp
[4,2] Caromel, Denis, and Julien Vayssiere, ProActive PDC web site. Online, Internet. Accessed 20 August, 1998. Available http://www.inria.fr/sloop/javall
[4,3] Caromel, Denis, and Julien Vayssiere. A Java Framework for Seamless Sequential, Multi-threaded, and Distributed Programming. ACM Workshop: Java for High-Peformance Network Computing (Stanford University, March, 1998) 141-150.
[4,4] Chalmers, Alan, JavaPP web page at Bristol. . Online, Internet. Accessed 26 July, 1998. Available http://www.cs.bris.ac.uk/~alan/javapp.html
[4,5] Crawford, George. JMPI description. Online, Internet. Accessed 3 August, 1998. Available http://mpi.mpi-softtech.com/publications/JMPI_121797.html
[4,6] Crawford, George. JMPI proposal. Online, Internet. Accessed 3 August, 1998. Available http://sbir.er.doe.gov/sbir/cycle15/phase1/abstract/70.htm
[4,7] Domrachev,M., V. Etch, S. Gaissaryan, V. Ivannikov, and N. Shtaltovnaya. DPJ web page. Online, Internet. Accessed 3 August, 1998. Available http://www.ispras.ru/~dpj
[4,9] Hartley, Stephen. Concurrent Programming: The Java Programming Language, Oxford: Oxford University Press, 1998.
[4,10] Herderink, Gerald, Jan Broenink, Wiek Vervoort, and Andre Bakkers. Communicating Java Threads. In A. Bakkers, Editor, Parallel Programming and Java, Proceedings of WoTUG 20, v. 50 of Concurrent Systems Engineering (Amsterdam, 1997), IOS Press.
[4,11] Herderink, Gerald, JavaPP web page at Twente. Online, Internet. Accessed 26 July, 1998. Available http://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 system structuring concept. CACM, (October, 1974) 17(10):549-557.
[4,14] Lea, Doug. Concurrent Programming in Java. New York: ACM Press, 1996.
[4,15] Lewis, Ted. The Binary Critic. IEEE Computer (March, 1997), 17(3):134.
[4,16] McCauley, Renee. Computer Science Education Links web page. Online. Internet. Accessed 19 August, 1998. Available http://www.cacs.usl.edu/~mccauley/edlinks
[4,17] Mitchell, Christine. JavaPVM web page. Online. Internet. Accessed 19 August, 1998. Available WWW: http://www.isye.gatech.edu/chmsr/jPVM
[4,18] Stein, Lynn. What We Swept Under the Rug: Radically Rethinking CS1. To appear in Computer Science Education. Online, Internet. Accessed 10 August, 1998. Available http://www.ai.mit.edu/people/las/papers/rug.html
[4,19] Stein, Lynn, Rethinking CS101 web page. Online, Internet. Accessed 20 August, 1998. Available http://www.ai.mit.edu/projects/cs101/publications.html
[4,20] Sun Microsystems, Inc. Java web page. Online, Internet. Accessed 20 August, 1998. Available http://www.sun.com/solaris/java
[4,21] Thornton, John. Cal Tech Structured Multithreaded Programming Projectweb page. Online, Internet. Accessed 26 July, 1998. Available http://threads.cs.caltech.edu .
[4,22] Welch, Peter. Java Threads in the Light of Occam/CSP. In A. Bakkers, editor, Parallel Programming and Java, Proceedings of WoTUG 20, v 50 of Concurrent Systems Engineering, Amsterdam:IOS Press, 1997
[4,23] Welch, Peter. Parallel and Distributed Computing in Education. University of Kent, U.K., 1998.
[4,24] Welch, Peter. Teaching How to Use Java for Parallel and Multi-threaded Computing. Panel presentation for panel "Using Java in Computer Science Education," at ITiCSE'97 conference, Uppsala, Sweden (June, 1997). Online, Internet. Accessed 20 August, 1998. Available http://www.cs.rit.edu/~ncs/Uppsala97
[5,1] J. Bishop, Java Gently, Second Edition, Addison-Wesley, Reading, MA, 1998.
[5,2] R. Decker and S. Hirshfield, programming.java, PWS Publishing, Boston, MA, 1998.
[5,3]J. Farley, Java Distributed Computing, OReilly, Sebastopol, CA, 1998. http://www.oreilly.com/catalog/javadc/noframes.html (code examples: ftp://ftp.ora.com/published/oreilly/java/javadc )
[5,4]D. Flanagan, Java Examples in a Nutshell, OReilly, Sebastopol, CA, 1997. http://www.oreilly.com/catalog/jenut/noframes.html (code examples: http://www.oreilly.com/catalog/jenut/examples )
[5,5]E.R. Harold, Java Network Programming, OReilly, Sebastopol, CA, 1997. http://www.oreilly.com/catalog/javanetwk/noframes .html (code examples: ftp://ftp.ora.com/pub/examples/java/java.netprog )
[5,6] M.A. Holliday, A Web-Based Introduction to Computer Networks for Non-Majors, ITiCSE98, Dublin, Ireland, August, 1998. http://www.cs.wcu.edu/~holliday/cware
[5,7] M.A. Holliday, A Web Page of Sample Assignments, http://www.cs.wcu.edu/~holliday/assgs .
[5,8] B. Holmes, Programming with Java, Jones and Bartlett, Sudbury, MA, 1998.
[5,9] Java Tutorial, Main Web Page, Javasoft, 1998. http://www.javasoft.com/docs/books/tutorial/index.html
[5,10]Java Tutorial, Networking subtutorial, Javasoft, 1998. http://www.javasoft.com/docs/books/tutorial/networking/index.html
[5,11] Java Tutorial, Servlets subtutorial, Javasoft, 1998. http://www.javasoft.com/docs/books/tutorial/servlets/index.html
[5,12]Java Tutorial, Security in JDK 1.1 subtutorial, Javasoft, 1998. http://www.javasoft.com/docs/books/tutorial/security1.1/index.html
[5,13]Java Tutorial, Security in JDK 1.2 subtutorial, Javasoft, 1998. http://www.javasoft.com/docs/books/tutorial/security1.2/index.html
[5,14] S.N. Kamin, M. D. Mickunas, and E.M. Reingold, An Introduction to Computer Science Using Java, WCB/McGraw-Hill, Boston, 1998.
[5,15] J. Lewis and W. Loftus, Java Software Solutions, Addison-Wesley, Reading, MA, 1998.
[5,16] Los Alamos National Laboratories, CORBA Resources web page, http://www.acl.lanl.gov/CORBA .
[5,17] R. McCauley, The Operating Systems, Parallel Computing, and Networks section of her Computer Science Education Links page, http://www.cacs.usl.edu/~mccauley/edlinks / #OperatingSystems. This page has some links to computer networks course material web pages some of which that involve using Java.
[5,18] R. Orfali and D. Harkey, Client-Server Programming with Java and CORBA, Second Edition, John Eiley, New York, New York, 1998. http://www.wiley.com/compbooks .
[5,19]L. L. Peterson and B.S. Davie, Computer Networks: A Systems Approach, Morgan Kaufmann, 1996. http://www.mkp.com/books_catalog
(Socket assignment examples: http://www.mkp.com/books_catalog/cn/sockets.htm )
[5,20]G. Reese, Database Programming with JDBC and Java, OReilly, Sebastopol, CA, 1997. http://www.oreilly.com/catalog/javadata
(code examples: ftp://ftp.ora.com/pub/examples/java/jdbc )
[5,21]P. Tymann, Introduction to Java Networking, Tutorial Slides from SIGCSE98, http://www.cs.rit.edu/~ptt/talks/javaNetworking/index.htm .
[6,1] Baldwin, R. On-line Java tutorial. Available: http://www.phrantic.com/scoop/onjava.html
[6,2] Barret, R. OODB module. Available http://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 Java and XML. John Wiley and Sons, Inc. 1998.
[6,5] Cooper, J. Using JDBC to Create Database Objects Available: http://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. JDBC Database Access with Java: A Tutorial and Annotated Reference. ACM Press, 1997.
[6,8] Holliday, M. A Web page of sample assignments Available: http://tinuviel.cs.wcu.edu/~holliday/assgs
[6,9] Horstman, C. and Cornell, G. Core Java 1.1 Volume II: Advanced Features (3rd ed.) Sun Microsystems Press, 1998.
[6,10] Idehen, K. Available http://www.openlink.co.uk/info/docs/opljdbc.html
[6,11] Jepson, B. Java Database Programming. John Wiley and Sons, Inc. 1996.
[6,12] MageLang Institute. JDBC Short Course. Available http://notes.krinfo.ch/jdbc/index.html
[6,13] MageLang Institute. JDBC Short course exercises Available http://notes.krinfo.ch/jdbc/jdbc/exercises.html
[6,14] Manning M. Teach Yourself Borland JBuilder in 14 Days] Sams.net Publishing, 1997.
[6,15] Orfali R. and Harkey D. Client Server Programming with Java and CORBA (2nd Ed.). John Wiley and Sons, Inc. 1998.
[6,16] Reese G. Database Programming with JDBC and Java. O'Reilly & Associates, Inc., 1997.
[6,17] Sun Microsystems JDBC FAQ Available: http://www.javasoft.com/products/jdbc/jdbc-frequent.html
[6,18] Sun Microsystems JDBC Overview Available: http://www.javasoft.com/products/jdbc/overview.html
[6,19] Tanler R. The Intranet Data Warehouse: Tools and Techniques for Building an Intranet Enabled Data Warehouse. John Wiley and Sons, Inc. 1997.
[6,20] Ullman, J. Principles of Database and Knowledge-Base Systems Vol.1. Computer Science Press, 1988.
[6,21] Yang, A., Linn, J., and Quadrato, D. "Developing Integrated Web and Database Applications Using Java Applets and JDBC Drivers." ACM SIGCSE Bulletin
[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 at http://www.ulst.ac.uk/cticomp
"Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee."