No abstract available.

Online courses have proliferated across all disciplines in recent years. One commonly-used approach for creating an online course is to build a web site containing as much course information---assignments, solutions, lecture notes, streaming videos, and the like---as possible. The goal of this type of course is to replicate online, to the maximum extent possible, the classroom experience. Online courses built this way exploit the communications capabilities of networked computers. We believe, however, that online courses should also strive to exploit the computational capabilities of computers. That is, online courses should provide value-added components that make possible learning experiences beyond what is feasible in the traditional classroom. We describe such an online course, called Creating Interactive Web Content, that we created and have taught successfully for the last three years. It is a general enrollment course that uses HTML and JavaScript as a vehicle for teaching elementary programming concepts.

Many educators believe that the most effective means of teaching is through one-on-one interactions with students. It is not surprising, then, that an effective way to teach programming is to give students immediate feedback on programs that they have just written. Unfortunately, such one-on-one teaching scenarios are becoming increasingly difficult to arrange. We built InSTEP, an online tutoring system for beginning C programmers, to see whether an automated system could provide effective immediate feedback to beginning programming students. In an introductory programming course, we compared two groups of students. One group solved six programming problems with feedback from InSTEP; the second group solved the same six problems without feedback from InSTEP; both groups had access to feedback from teaching assistants. While both groups of students took about the same amount of time to complete the problems and performed about the same on a subsequent test, the students who received feedback from InSTEP spent less than a third of the time asking the teaching assistants questions than did the others.

The ability to think abstractly about the components of a computer program is critical for computer science students. A student who has not yet developed this ability tends to view a program as an unstructured collection of statements and expressions. Introductory computer science textbooks promote the use of pre-conditions, post-conditions, and abstraction functions as techniques for fostering abstract thinking. Existing programming languages and tools, however, do not generally support these techniques. Consequently, we have built and are beginning to experiment with Javiva. Javiva extracts pre-conditions, post-conditions, and abstraction functions---included as stylized comments in Java source files---and uses them to create instrumented class files. When these instrumented class files are run, they automatically diagnose and report violations by methods of pre- and post-conditions. These classes also exploit abstraction functions to automatically produce abstract visualizations of their objects.

NaturalJava is a prototype for an intelligent natural-language-based user interface for creating, modifying, and examining Java programs. The interface exploits three subsystems. The Sundance natural language processing system accepts English sentences as input and uses information extraction techniques to generate case frames representing program construction and editing directives. A knowledge-based case frame interpreter, PRISM, uses a decision tree to infer program modification operations from the case frames. A Java abstract syntax tree manager, TreeFace, provides the interface that PRISM uses to build and navigate the tree representation of an evolving Java program. In this paper, we describe the technical details of each component, explain the capabilities of the user interface, and present examples of NaturalJava in use.

A typical CS2 course has two goals that often work at cross-purposes. One goal is to teach students how to apply a variety of software engineering skills to create solutions to real-world problems. A second goal is to teach students the theory and practice behind classical algorithms and data structures. The use of small, short-term programming assignments, however, tends to sacrifice the first goal in favor of the second. We successfully experimented with solving this problem by organizing a CS2 course around a programming project that spanned an entire term. This paper describes the project, our experiences in using it, and the reactions of the students.

No abstract available.

No abstract available.

No abstract available.

The process of solving a problem in computational science neither begins nor ends with designing and writing a computer program. The process entails isolating the problem, devising a mathematical model, identifying a computational method, producing an implementation, and assessing the solution. Unfortunately, the introductory programming courses taken by science and engineering students frequently focus only on implementation issues. As a result, such students are often ill-equipped to solve computational problems.We have created a course and written an accompanying textbook that present an introduction to scientific programming. Both are organized around the process for solving computational science problems sketched above. In this paper we illustrate this approach by describing two representative problems from the course and textbook. Along the way, we present Java applets that were designed to illustrate some of the ideas that underlie the two problems.

No abstract available.

No abstract available.

article An entry-level course in computational engineering and science Share on Authors: Joseph L. Zachary Department of Computer Science, University of Utah, Salt Lake City, UT Department of Computer Science, University of Utah, Salt Lake City, UTView Profile , Christopher R. Johnson Department of Computer Science, University of Utah, Salt Lake City, UT Department of Computer Science, University of Utah, Salt Lake City, UTView Profile , Eric N. Eide Department of Computer Science, University of Utah, Salt Lake City, UT Department of Computer Science, University of Utah, Salt Lake City, UTView Profile , Kenneth W. Parker Department of Computer Science, University of Utah, Salt Lake City, UT Department of Computer Science, University of Utah, Salt Lake City, UTView Profile Authors Info & Claims ACM SIGCSE BulletinVolume 27Issue 1March 1995 pp 209–213https://doi.org/10.1145/199691.199786Online:15 March 1995Publication History 10citation193DownloadsMetricsTotal Citations10Total Downloads193Last 12 Months2Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access

By encapsulating aspects of language semantics within a set of default classes and allowing the programmer to derive new versions, object-oriented languages whose semantics can be tailored to the needs of individual programmers have been provided. The degree to which such languages are simultaneously flexible and efficient is an open question. We describe our experience with using this technique to incorporate transparent support for persistence into the Common Lisp Object System via its metaobject protocol, an open implementation based on reflection. For many aspects of our implementation the metaobject protocol was perfectly suitable. In other cases we had to choose between extending the protocol, requiring the application programmer to employ special idioms, and tolerating a large performance penalty. Based on our experience we evaluate the metaobject protocol, propose some improvements and extensions, and present performance measurements that reveal the need for improved language implementation techniques.>

In a typical programming class, students watch and listen as instructors explain and demonstrate e key concepts through the use of blackboards, overhead projectors, and computer screen projection.Students then move to computer laboratories and solve programming assignments, more or less on their own.There is little opportunity for machine interaction in the lecture hall, and little opportunity for human interaction in the laboratory.In the Department of Computer Science at the University of Utah, we have made substantial progress in merging the lecture and laboratory experiences into something greater than the sum of its parts.We have developed a computerbased learning environment and a set of online tutorials for teaching introductory courses in Unix, C, and Fortran.We have been teaching our Unix course using this technology for three years, and our Fortran and C courses for two years.In all three courses, which have served over 1700 students during this period, we have completely eliminated the lecture component.Student evaluations for all three courses are now higher than they were under the old lecture format.During the summer of 1991 we developed software and courseware for teaching Unix to science and engineering undergraduates.We incorporated these developments into our curriculum beginning with the 1991-92 academic year.During the summer of 1992, we built upon our Unix experience by developing courseware for teaching introductory coumes in Fortran and and C. We incorporated this work into our curriculum during the 1992-93 academic year. 1 A Tutorial-Based Unix Class

Most of the theoretical work on the semantics of logic programs assumes an interpreter that provides a complete resolution procedure. In contrast, for reasons of efficiency, most logic programming languages are built around incomplete procedures. This difference is rooted in Prolog, which evaluates resolvent trees in a depth-first rather than a breadth-first order. The gap is widened by some equational logic languages, which combine the incompleteness of depth-first evaluation with incomplete approximations to equational unification. Because of this gap, it is unsound to reason about logic programs using their declarative semantics. This in turn makes it difficult to develop abstraction mechanisms that can be used to partition a logic program into independently specifiable modules.