bluuebunny/crossref_metadata_2025 huggingface dataset:
Starting top-down, refining bottom-up, sharpening by zoom-in
Authors: Ginat David
Published: July 2004

We illustrate with colorful algorithmic problems two solution processes that embed three primary computer science problem-solving approaches. The first, Top-Down approach is rather naturally invoked for formulating elegant, though inefficient divide-and-conquer rules. The second, Bottom-Up approach is utilized to considerably improve efficiency of the Top-Down solution. The third, Zoom-In approach sharply captures the precise essence of the problem characteristics and yields remarkably concise solutions.
Teaching programming from a distance
Authors: Renaud Karen , Barrow John , le Roux Petra
Published: July 2004

Teaching programming is never a simple task. It is a dynamic process and the curriculum often evolves from one year to the next. Teaching programming at a distance-education institution is especially challenging. This paper reports on the process of curriculum planning at the computer science department of a distance-education institution. We address generic issues related to teaching programming and specific problems encountered when teaching at a distance. The paper outlines and motivates our proposed strategy, which encompasses three years of undergraduate teaching.
The human-computer interface
Authors: Ryan Christopher D.
Published: July 2004

Designers often treat interface and navigation as afterthoughts in educational multimedia and web design, to the detriment of their prospective learners. A review of the literature provides clues to designing a more usable interface and navigation structure that both aides and engages learners. A look at the past and future of interface design allows designers to glean valuable information and ideas for improving the usability, as well as the educational value, of their products. Concentrating on simplicity and consistency, and keeping flashy design and color to a minimum, designers can create attractive products that promote learning.
Striving for mathematical thinking
Authors: Henderson Peter B. , Baldwin Doug , Dasigi Venu , Dupras Marcel , Fritz Jane , Ginat David , Goelman Don , Hamer John , Hitchner Lew , Lloyd Will , Marion Bill , Riedesel Charles , Walker Henry
Published: July 2004

Computer science and software engineering are young, maturing disciplines. As with other mathematically based disciplines, such as the natural sciences, economics, and engineering, it takes time for the mathematical roots to grow and flourish. For computer science and software engineering, others have planted these seeds over many years, and it is our duty to nurture them. This working group is dedicated to promoting mathematics as an important tool for problem-solving and conceptual understanding in computing.
Host/target approach to embedded system development is becoming obsolete
Authors: Tardy J. E.
Published: July 2004

For many years, the primary mode of development for real-time embedded software has been the "host/target" approach. In this approach, the software for the application is developed on one computer system to be executed on another. The increased memory and speed of embedded hardware has now reached a point where these systems are capable of supporting both their real-time applications and the software engineering environments for their development. This has made the acceptance of the higher risk and complexity inherent to the host/target approach an undesirable strategy.The shift back to self-targetted development for embedded software will have important consequences in the future of Software Engineering Environments. It also heralds the emergence of a new type of computer system: The General Purpose Embedded Computer.
Model exploration with temporal logic query checking
Authors: Gurfinkel Arie , Devereux Benet , Chechik Marsha
Published: July 2004

A temporal logic query is a temporal logic formula with placeholders. Given a model, a solution to a query is a set of assignments of propositional formulas to placeholders, such that replacing the placeholders with any of these assignments results in a temporal logic formula that holds in the model. Query checking, first introduced by William Chan [2], is an automated technique for finding solutions to temporal logic queries. It allows discovery of the temporal properties of the system and as such may be a useful tool for model exploration and reverse engineering.This paper describes an implementation of a temporal logic query checker. It then suggests some applications of this tool, ranging from invariant computation to test case generation, and illustrates them using a Cruise Control System.
Longitudinal program analysis
Authors: Notkin David
Published: July 2004

The field of program analysis has made significant improvements recently, but still faces some major obstacles. In this talk I argue that considering analysis as applying longitudinally across the multitude of versions created during a program's lifetime -rather than to a given instance of a program - shows significant promise in overcoming some of these obstacles. I focus on identifying a set of opportunities that arise when this shift in outlook is taken.Most program analysis techniques have focused on questions of the form "Does program P satisfy a given property A?" or "What program points in P satisfy a given property A?" Type-checking is the classic example of the first form, while lexical, syntactic, and semantic analyses are examples of the second form. The key point (with respect to this talk) is that a single program P is being analyzed.Some analyses expand this view and explicitly consider a pair of programs, P and P', where P' represents a modified version of P. Test selection and prioritization techniques are among the best examples of this approach: the idea is to analyze the delta between P and P', and to use that information to determine which test cases must be re-run (for test selection) or should be re-run (for test prioritization). (There are dozens of results in these areas; Harrold et al.'s empirical study is one recent example of test selection [1], and the recent work at Microsoft Research is an example of test prioritization [2].There are at least three ways in which a longitudinal approach could improve analysis.Second, we can use previously computed information to better inform analysis on a newer version. One recent example of this is the work by Kim and Porter that uses historical information about the application of tests of a set of versions as a basis for test prioritization algorithms [3].Third, we can imagine applying otherwise "intractable" analyses over the lifetime of (multiple versions of) a program, as opposed to the (much more limited) time available to analyze a specific version. In essence, there is an opportunity to compute the analysis in stages, with the goal of completing the analysis by specific important points in the program lifetime (e.g., external releases). Work on vertical staging of analyses for runtime compilation is one place to look for ideas and techniques for this kind of "horizontal" staging [4].The traditional view of software evolution says that (to accommodate needed change) program structure degrades and program size increases [5][6]; this in turn tends to increase the difficult of analysis. I propose here some opportunities for viewing time and change as potential benefits with respect to analysis, rather than as roadblocks. This provides potential for significantly improving software dependability over time.
Instruction-level reverse execution for debugging
Authors: Akgul Tankut , Mooney Vincent J.
Published: July 2004

The ability to execute a program in reverse is advantageous for shortening debug time. This paper presents a reverse execution methodology at the assembly instruction-level with low memory and time overheads. The core idea of this approach is to generate a reverse program able to undo, in almost all cases, normal forward execution of an assembly instruction in the program being debugged. The methodology has been implemented on a PowerPC processor in a custom made debugger. Compared to previous work -- all of which use a variety of state saving techniques -- the experimental results show 2.5X to 400X memory overhead reduction for the tested benchmarks. Furthermore, the results with the same benchmarks show an average of 4.1X to 5.7X time overhead reduction.
STEP
Authors: Brown Rhodes , Driesen Karel , Eng David , Hendren Laurie , Jorgensen John , Verbrugge Clark , Wang Qin
Published: July 2004

Traditional tracing systems are often limited to recording a fixed set of basic program events. This limitation can frustrate an application or compiler developer who is trying to understand and characterize the complex behavior of software systems such as a Java program running on a Java Virtual Machine. In the past, many developers have resorted to specialized tracing systems that target a particular type of program event. This approach often results in an obscure and poorly documented encoding format which can limit the reuse and sharing of potentially valuable information. To address this problem, we present STEP, a system designed to provide profiler developers with a standard method for encoding general program trace data in a flexible and compact format. The system consists of a trace data definition language along with a compiler and an architecture that simplifies the client interface by encapsulating the details of encoding and interpretation.
Combining static and dynamic data in code visualization
Authors: Eng David
Published: July 2004

The task of developing, tuning, and debugging compiler optimizations is a difficult one which can be facilitated by software visualization. There are many characteristics of the code which must be considered when studying the kinds of optimizations which can be performed. Both static data collected at compile-time and dynamic runtime data can reveal opportunities for optimization and affect code transformations. In order to expose the behavior of such complex systems, visualizations should include as much information as possible and accommodate the different sources from which this information is acquired.This paper presents a visualization framework designed to address these issues. The framework is based on a new, extensible language called JIL which provides a common format for encapsulating intermediate representations and associating them with compile-time and runtime data. We present new contributions which extend existing compiler and profiling frameworks, allowing them to export the intermediate languages, analysis results, and code metadata they collect as JIL documents. Visualization interfaces can then combine the JIL data from separate tools, exposing both static and dynamic characteristics of the underlying code. We present such an interface in the form of a new web-based visualizer, allowing JIL documents to be visualized online in a portable, customizable interface.
A mentor program in CS1
Authors: Miller Amanda , Kay Judy
Published: July 2004

Mentor programs are a highly effective way of assisting students with the transition from high school to university. This paper documents the introduction of the mentor program in our department. In this program, higher year students volunteered to act as mentors to incoming freshmen. Mentors fulfilled technical and social roles assisting freshmen with the transition to university and with their studies in computer science.We explain the details of mentor selection and their activities during the semester. We evaluate the outcomes of mentoring for students, mentors and the department.
You'd better set down for this!
Authors: Alm Jacob , Baber Robert , Eggers Shauna , O'Toole Christopher , Shahab Abin
Published: July 2004

The authors have developed a set class and other supporting materials that would be useful for a CS1 and CS2 course taught in the C# programming language developed by Microsoft Corporation [1]. The primary goals were to create a data structure that would be simple and intuitive enough for novices to use in CS1 but also powerful enough to be useful for CS2 students. In addition to the set class itself the authors have developed several sample programs and an interactive set environment. In developing these materials the authors explored the expressive capabilities of the C# language and found that it was particularly well suited to this task.
Illustrating networking concepts with wireless handheld devices
Authors: Richards Brad , Waisbrot Nate
Published: July 2004

We are developing innovative new laboratory materials that give students a hands-on introduction to both traditional and wireless networking concepts. Our labs are designed around the Cybiko, a powerful multi-functional wireless handheld computer that sells for less than $50. The materials can be used to augment existing networking courses or as the core of a new upper-level course. This paper describes the labs completed to date, our plans for the future, and presents the results of a comparative study using the labs to demonstrate routing algorithms.
Do cognitive styles affect learning performance in different computer media?
Authors: Parkinson Adrian , Redmond James A.
Published: July 2004

The impact of three treatments Text, CD-ROM, Internet site and student Cognitive Styles on learning performance was investigated. Prior to the commencement of the course the students completed the following psychometric tests: the Group Embedded Figures Test (GEFT) [1], Kirton's Adaptive-Innovator Inventory (KAI) [2] and Cognitive Styles Analysis (CSA) [3]. The subject matter was an Introductory Course in Artificial Intelligence. Forty-seven final year Information System students participated, randomly assigned within sexes to one of the three treatments. Upon completion of six one-hour sessions they were given a sixty-minute examination to assess overall learning.It was found that only Field Dependence-Field Independence interacted with overall learning performance at a statistically significant level (p 0.001) irrespective of treatment. When the three treatments were investigated separately the results suggest that Verbalisers performed better than Imagers in the Internet treatment, while the Analytics performed better than the Wholists in the CD-ROM treatment. The results of the study are discussed in terms of individual differences (Cognitive Styles) together with implications for Web site design.
Object orientation in CS1-CS2 by design
Authors: Alphonce Carl , Ventura Phil
Published: July 2004

This paper argues for a design driven approach to an object-oriented CS1-CS2 sequence in which object-orientation is thematic. Our approach integrates several components: (i) a strong object-oriented approach, (ii) design using UML, (iii) design patterns to manage complexity, and (iv) complex examples and projects to motivate the use of object-orientation and to motivate students by solving non-trivial problems. While this is a "programming-first" approach to CS1-CS2, it addresses several disadvantages of programming-first approaches noted in CC2001 [7]. The approach focuses on design rather than syntax, so students do not lose sight of the forest for the trees. We use (relatively speaking) large and complex examples, especially in the CS2 course, which allows us to address in a meaningful way issues of programming in the large. Because the approach is design driven and heavily object oriented, the course is not biased against novices in favor of students with prior programming experience, since CS1 students with prior programming experience typically have no design experience and only procedural programming experience.
Hashing revisited
Authors: Hamer John
Published: July 2004

Hashing is a singularly important technique for building efficient data structures. Unfortunately, the topic has been poorly understood historically, and recent developments in the practice of hashing have not yet found their way into textbooks.This paper revisits the theory and practice of hashing in a modern light, relates our teaching experiences, and presents some suggestions for student exercises.
The case of base cases
Authors: Haberman Bruria , Averbuch Haim
Published: July 2004

Recursion is a central concept in computer science, yet it is a very difficult concept for beginners to learn. In this paper we focus on a specific aspect of comprehending recursion - the conception of the base case as an integral component of a recursive algorithm. We found that students have difficulties in identifying base cases: they handle redundant base cases; ignore boundary values and degenerated cases; avoid out-of-range values; and may even not define any base cases when formulating recursive algorithms. We also found that students have difficulties in evaluating recursive algorithms that deal with imperceptible base cases. We suggest that teachers should make a special effort to discuss different aspects of the base case concept. Emphasis should be put on both declarative and procedural aspects of categorizing and handling base cases as part of recursion formulation.
Channels, visualization, and topology editor
Authors: Carr Steve , Chen Ping , Jozwowski Timothy R. , Mayo Jean , Shene Ching-Kuang
Published: July 2004

This paper presents our effort in designing pedagogical tools for teaching message passing using channels. These tools include a class library that supports channels, a visualization system that helps students see the execution behavior of threads and message passing, and a topology editor that provides an environment for students to design network topologies. Moreover, since we have made sure the uniformity of the channel de.nition across the thread, parallel and distributed environments, porting a threaded program to a parallel/distributed environment is easy.
A java toolkit for teaching distributed algorithms
Authors: Schreiner Wolfgang
Published: July 2004

We present a toolkit for developing and visualizing distributed algorithms in Java. This toolkit consists of a Java class library with a simple programming interface that allows to develop distributed algorithms in a message passing model. The resulting programs may be executed in standalone mode using a Java interpreter or embedded as applets into HTML documents and executed by a Web browser. The toolkit has been applied in various university courses and is freely available.
eTutorials with voice groupware
Authors: Rapanotti Lucia , Blake Canan Tosunoglu , Griffiths Robert
Published: July 2004

This paper reports on an investigation into the use of real-time voice groupware to support students on a computing course offered by the Open University, UK. The main objective of the investigation was to assess the feasibility and pedagogical advantage of deploying synchronous conferencing technology on a large population computing course to complement existing face-to-face and asynchronous online support for its students. In this paper we report on the findings from such an investigation, and draw a number of conclusions and recommendations covering feasibility, scalability and best practice in the use of voice groupware for eLearning.
Formative evaluation scheme for a web-based course design
Authors: Meisalo Veijo , Suhonen Jarkko , Torvinen Sirpa , Sutinen Erkki
Published: July 2004

In Fall 2000, University of Joensuu offered for the first time a Web-based university level Computer Science course to high school students in the surrounding rural region of North Karelia. To improve the course design, a formative evaluation scheme was developed for monitoring learning outcomes and identifying existing problems, pedagogical as well as technical. An analysis of the feedback given by those who dropped out of the pilot program offered important insights to the difficulties encountered by the students especially during the programming course. The main reasons for quitting were the problems to synchronize high school and university studies, given tight time constraints. Use of arrays and designing methods proved to be among the most difficult topics of programming. Based on the analyzed feedback, the curriculum has been modified to fit better to students' potential.
Learning from students
Authors: Last Mary Z. , Daniels Mats , Hause Martha L. , Woodroffe Mark R.
Published: July 2004

Just a few years ago, incorporating team projects in a course meant that all students had to be collocated, able to meet face-to-face. Now, distributed teams use the Internet and other technologies to work across time and distance. Instructors who include distributed team projects in their courses add the dimensions of collaborative technologies, language, and culture to the technical problem-solving and team-building aspects. Continuous improvement in course structure and content are necessary to meet the changing needs of students as well as the changes in technology. This paper traces the evolution of a distributed project course offered since 1998. Each time the course has been run, students, faculty, and researchers have learned important lessons, which have been used to improve successive course offerings.
On using the web as a collaboration space in the context of an industrial simulation
Authors: Ratté Sylvie , Caron Jocelyne
Published: July 2004

We present a teaching method aimed at developing higher programming skills from description to production. The model is derived from problem-based learning approaches. It is supported by an "incremental" web site that gradually introduces theoretical presentations, examples, programs and information regarding the problem. The web site is also used as a collaboration space where students can find partial solutions proposed by other teams as well as "requests" submitted by a fictitious client. At the end of the project, each product is published and the best teams are awarded a virtual medal.We had four objectives. The first was to get students to share their expertise and learn to work in teams; second, to teach students the importance of doing a conceptual analysis rather than jumping into programming; third, to introduce theoretical notions, exercises, and examples in class when the students asked for them; and finally, to get students to formulate and describe problems by themselves.Students had to produce a large-scale project that consisted of simulating a factory. The project can be understood at two levels: the first is the problem of developing a discrete simulation of a factory; the second is the creation of the program itself which simulates the industrial context by requiring constant adjustment to new instructions and data.Although this approach requires a lot of effort and coordination on the part of the instructor, the benefits are definitely worthwhile. The model provides students with a broad, in-depth and rewarding learning experience.
Tool support for collaborative teaching and learning of object-oriented modeling
Authors: Hansen Klaus Marius , Ratzer Anne Vinter
Published: July 2004

Modeling is central to doing and learning object-oriented development. We present a new tool, Ideogramic UML, for gesture-based collaborative modeling with the Unified Modeling Language (UML), which can be used to collaboratively teach and learn modeling. Furthermore, we discuss how we have effectively used Ideogramic UML to teach object-oriented modeling and the UML to groups of students using the UML for project assignments.
A virtual network laboratory for learning IP networking
Authors: Fàbrega Lluís , Massaguer Jordi , Jové Teodor , Mérida David
Published: July 2004

In this paper, a network laboratory for distance learning of basic concepts in IP networking is presented. Through a web interface, students can choose various configurations of a real private network (number of routers and subnetworks, use of IPv4/IPv6, etc.), and learn about them using Linux network commands. The utilization of the virtual laboratory and how it is implemented are described.
Variability of referees' ratings of conference papers
Authors: Walker Henry M. , Ma Weichao , Mboya Dorene
Published: July 2004

The authors developed an on-line system to automate the paper submission and reviewing process for SIGCSE 2000. This system provided a mechanism for a statistical study of the ratings of papers by different referees. To compile sufficient sample data, 10 papers were sent to about 100 referees each, in addition to the normal reviewing of the 220 submitted papers. This paper reports the results of this work, based on 1917 reviews completed by 482 referees. The data support correlations of a paper's overall rating with internal factors (technical content, writing quality, originality, significance) and external factors (referee gender, nationality, familiarity with topic, etc.). The study also shows the effect of group reviews (similar to NSF panels), and the divergence of opinions between authors and referees concerning a paper's subject.
Improving feedback from multiple choice tests
Authors: Fone William
Published: July 2004

Providing individual feedback to large groups of students can be difficult. By asking students to record their confidence in multiple choice test answers the quality of feedback can be improved. In a "multiple choice question" (MCQ) test the student is asked to make a selection of one or more correct alternatives from a given list in response to a "question stem".Students rely heavily upon the teacher to provide academic guidance. To provide individualised guidance to student when group sizes are large can be difficult. Feedback can be used to inspire a student but it may also demoralise. De-motivation may occur if the student does not understand the feedback or can not use it to determine the correct remedial action to improve. To provide advice that a student can use effectively will normally require the advice to be personalised. [1].The methods used to reduce the distortion that could be caused by guessing include negative marking and value choice [2]. In both these situations the student may pay a penalty for attempting a question where there is an element of uncertainty. A student with doubts may avoid answering some questions if negative marking is being used. This limits the amount of useful information a grader can obtain from looking at an answer sheet.
The student record book
Authors: Gibson Robyn
Published: July 2004

Students in an introductory programming subject are encouraged to keep a record book of their activities. By the end of semester many have come to realise, almost to their surprise, that documentation is useful. The encouragement includes the use of "carrots" and "sticks".
Self-assessment as a powerful learning experience
Authors: Lapidot Tami
Published: July 2004

Every teacher would like to have students that are motivated towards autonomous learning with self-enthusiasm. This Tip presentation will offer one method for achieving such a goal.For three consequential years (1998-2000) I was teaching a "computing literacy teaching methods" course for CSE students in the Technion. The focus of the course was on computing teaching methods and learning processes.A major part of the course was devoted to a project the students had to develop. They had to collect data, analyze it, organize and represent it to their colleagues. They had to work in small teams and could choose their own topic as long as they were using different computing tools such as Internet, email, spreadsheet, and others.The projects ranged topics such as: Wine, women in Islam, Michelangelo, UFO, wedding traditions, Greek mythology, and Marathon history.
Pedagogical patterns
Authors: Fincher Sally , Utting Ian
Published: July 2004

This paper describes some constituents of patterns and pattern languages and examines the Pedagogical Patterns endeavour against them. Some observations are made with regard to how pattern languages are developed and some suggestions as to how these might be applied to pedagogical patterns are made.
The emporium approach to computer science education
Authors: Lee J. A. N.
Published: July 2004

As an alternative to laboratories for computer science programming courses, the Emporium style of learning environment has advantages for a course concerned with the foundations and principles of computer science. Following the lead from courses in freshman mathematics, this paper describes the active learning and assessment methodologies incorporated into a freshman computer science course. The results have been encouraging, and student acceptance of an alternative approach to learning is improving.
Increasing learning and decreasing costs in a computer fluency course
Authors: Walters Deborah , Alphonce Carl , Sherman Barbara , Burhans Debra , Kershner Helene
Published: July 2004

This paper presents the results of a redesign of a large enrollment computer fluency course for non computer science majors. The goals of the redesign were to increase learning and to decrease costs using technology. The paper discusses the motivations and the components of the course redesign. The results show that costs did decrease and that learning did increase in the redesigned course.
A studio-based teaching and learning model in IT
Authors: Carbone Angela , Sheard Judy
Published: July 2004

The change to a studio based teaching model in one core subject of a traditionally delivered IT degree has necessitated a complete redesign of the teaching space and a restructure of the teaching and learning approach. This paper reports on first year students' reactions to the new learning space, the IT tools and infrastructure, the change in teaching philosophy and a new method of assessment. A survey was used determine how the students used the new environment and their perceptions of its value to their learning compared to the traditional lecture-tutorial style approach.
Innovation in software engineering education
Authors: Young Alison , Mann Samuel
Published: July 2004

This poster describes a study that brings together two areas of research into improving education practice in the field of software engineering. In a deliberate attempt to emulate real world software development, software engineering students project groups were required to swap projects without warning, mid way through their development cycle. This is numerically and quantitatively assessed against Robinson's [1] attitudes and practices of empowering education. Implications of further work and possible collaborations or joint projects are considered along with the theoretical context of the study. The lessons learned from this research may apply to a wider sphere, particularly in software engineering areas where efforts are made to prepare students for careers in changing and difficult environments.
Integrating the history of systems software in the computing curriculum
Authors: Impagliazzo John
Published: July 2004

The study of the history of computing system software has begun to receive some attention lately. Areas involving operating systems and programming languages have recently attained greater scholarly awareness and have developed into new areas of research. The scope of system software is rather broad and can lead to detailed studies in very specialized areas.The separation between system software and application software was not precise in the early days of computing. As educators and scholars, we should be careful not to examine that early history only through our current point of view. Time allows us to observe such events with different perspectives. Successes and failures in the systems area require balance. Indeed, it is important to consider failures because they may have contributed many ideas and concepts to software development even though companies did not incorporate them in their final products. The study of early system software also requires that we look at the practices of the businesses as well as the technology at that time and the dynamic forces that determined the outcome of a product.
Implementing student ideas in CS2
Authors: Wyatt Jason N. , Kosa Martha J. , Boshart Mark A.
Published: July 2004

It is very hard for faculty members to create programming assignments that are simultaneously challenging, accessible, and practical for students year after year. In some advanced undergraduate courses, most notably software engineering courses, students may specify their own programming projects. We demonstrate here that it is also possible for beginning undergraduate students to have good ideas for realistic programming projects, specifically a simple IDE (Integrated Development Environment) program which lets the user generate a basic GUI. The program then produces as output a Java source file, with some event-handling code, which can reproduce the GUI. Of course, we can't and don't expect the program to have all the features of a professional IDE, but it could be useful for CS1/CS2 students.A freshman CS2 student conceived and implemented this assignment in the Spring 2001 semester as part of an honors contract. Honors students elect to do extra work in courses for credit toward graduation with honors. Such a student designs a contract, to be approved by the instructor, indicating the extra work and its effect on the final grade. Although an honors student developed this project, this project is suitable in general for CS2 students.We now describe the features of the project. A settings frame and a drawing frame appear first. The settings frame allows the user to name the Java output file. It also has a Save button, a text field to control the arrow keys, and checkboxes that allow the user to choose if a main method will appear in the output file, if the resulting application frame will be centered on the screen, and if window listener code will be generated for the application frame. The right mouse button is used to add a component. When the mouse is released, the user chooses the component's type and then the desired variable name and caption. Components appear as black unfilled rectangles. The component declarations (alphabetically by variable name) and skeleton code for handling button clicks will appear in the output file. Clicking the left mouse button in a rectangle turns the rectangle red. The shift key and the left mouse button move such a component. The arrow keys resize the component. Component sizes will be preserved in the output file. The component's properties are updated with the C key. The delete key removes the component.We believe that this project is a challenging (but not impossible) and useful application of CS2 concepts.
EnViDiA
Authors: Holdfeldt Peter , Koldehofe Boris , Lindskog Carina , Olsson Torbjörn , Petersson Wanja , Svensson Jonas , Valtersson Linus
Published: July 2004

EnViDiA is an extensible environment that visualizes the execution of distributed algorithms by using the visualization enhancements offered by Virtual Reality technology. It addresses to represent the complex flow of information tied with the execution of a distributed algorithm in a way that also novices can easily develop a first understanding of the algorithm behavior. In difference to already existing tools it represents the communication structure in a 3D-model in which users are immersed. This way a natural interaction based on real world behavior is possible.The algorithm must work correctly using any arbitrary inter-connection of processes represented by a communication graph. In contrast to ordinary 2D-worlds, complex non-planar graph models can be nicely represented in 3D with the perspective adapting to the movements of the user. Further, the orientation in the 3D-world is facilitated providing spatial sound. It assists the user becoming aware of the important system events.Students working within such an environment are more active since they walk or fly through the distributed system world in a game like scenario. Unlike the textbook approach students perceive a whole system execution instead of a series of snapshots for which students may experience difficulties in connecting them. The given experience is intended to help the students to follow better the formal descriptions and analysis of such algorithms.Undergraduate students have developed EnViDiA as part of the LYDIAN [2] project. The animation framework was designed for the Chalmers VR-Cube [1], an immersive VR environment and it is based on the problems the students experienced themselves when studying distributed algorithms for the first time.Although EnViDiA is intended to be used in an immersive VR environment, it is also possible to use EnViDiA in a simpler version on ordinary desktop computers supporting 3D-graphics (c.f. Figure 1). At its current state EnViDiA supports three distributed algorithms namely simple broadcast, broadcast with acknowledgement and resource allocation based on the algorithm by Ricart and Agrawala. The algorithms are taught in a basic distributed system course at Chalmers University of Technology.The development is about to be continued as part of the LYDIAN [2] project. Besides adding more algorithms and evaluating the tool at its current state, the main focus is on providing features to support multiple user collaboration, which are tested at the distributed concept of self-stabilization.
AλgoVista
Authors: Collberg Christian , Kobourov Stephen G. , Miller Jessica , Westbrook Suzanne
Published: July 2004

AλgoVista is a web-based search engine that assists programmers to and algorithms and implementations that solve specific problems.The search engine is not keyword based but rather requires users to provide (input = ?output)samples that describe the behavior of their needed algorithm. AλgoVista is based on a technique known as program check-ing pioneered in the last decade by Manuel Blum [1 ]as an alternative to program verification and testing.Program checking extends programs with checkers to allow them to verify the correctness of the results they compute.
"Machshava"
Authors: Israel National Center for Computer Science Teachers
Published: July 2004

In this poster, we present the Israeli national center for high school Computer Science teachers.
MediaMime
Authors: Stewart Avare' , Kermani Parviz , Mourad Magda
Published: July 2004

Studies have shown that e-Learning is one of the fasted growing trends in higher education. This evolving trend can be classified with respect to the underlying structure and content of these environments. Of particular note is an e-Learning environment which is structured asynchronously and whose content is based solely on an electronic medium. In such environments, classes may never actually meet and the only form of delivery may be via an electronic lecture system. Given this environment, how do we maintain the benefits of the traditional classroom setting while still offering students the flexibility they may need in having the asynchronous environment in the first place? Furthermore, given an electronic-only delivery mechanism, how can both the student and the instructor tailor e-Learning content to suit their needs. We propose a flexible media-rich instructional method which: 1) facilitates collaboration in an asynchronous, electronic lecture environment and 2) supports the context-based, post-production augmentation and exchange of user-defined supplements which allows an author to refine and tailor e-Learning content.
WWW visualisation of computer architecture simulations
Authors: Ibbett Roland N.
Published: July 2004

Simulation models of a number of computer architectures have been created using HASE,a Hierarchical Computer Architecture design and Simulation Environment,and automatially translated into WebHASE... and JavaHASE applets which can be accessed via the WWW.These applets are being used both as visual aids and or student exercises.
Research directions in RAIC
Authors: Liu Chang , Richardson Debra J.
Published: July 2004

Redundant arrays of independent components (RAIC) was a technology developed to use groups of similar software components to build reliable applications. The principles of RAIC, however, can be applied to other types of components. This paper briefly introduces RAIC and discusses future research directions in RAIC.
Principles of survey research part 6
Authors: Kitchenham Barbara , Pfleeger Shari Lawrence
Published: July 2004

This article is the last of our series of articles on survey research. In it, we discuss how to analyze survey data. We provide examples of correct and incorrect analysis techniques used in software engineering surveys.
On the Latest Development in Cognitive Informatics
Authors: Wang Yingxu
Published: July 2004

Cognitive informatics is a cutting-edge and profound interdisciplinary research area that tackles the common root problems and foundations of modern informatics, computation, software engineering, AI, and life sciences. Cognitive informatics is a new frontier that studies internal information processing mechanisms and processes of the brain, and their engineering applications in computing, software, and IT industries. The functional architecture of the brain and the natural intelligence of the mind are the last domain yet to be explored in cognitive informatics.This article reports the latest development at the First IEEE International Conference on Cognitive Informatics (ICCI '02). This report intends to draw attention of researchers, practitioners and graduate students on the investigation of cognitive mechanisms and processes of human information processing, and to stimulate the collaborative international effort on cognitive informatics research and engineering applications.
Value-based software engineering
Authors: Boehm Barry
Published: July 2004

Much of current software engineering practice and research is done in a value-neutral setting, in which every requirement, use case, object, and defect is treated as equally important; methods are presented and practiced as largely logical activities; and a "separation of concerns" is practiced, in which the responsibility of software engineers is confined to turning software requirements into verified code. In earlier times, when software decisions had relatively minor influences on a system's cost, schedule, and value, the value-neutral approach was reasonably workable. But today and increasingly in the future, software has a major influence on most systems' cost, schedule, and value; and value-neutral software decisions can seriously degrade project outcomes.This paper presents an agenda for a discipline of Value-Based Software Engineering. It accepts the challenge of integrating value considerations into all of the existing and emerging software engineering principles and practices, and of developing an overall framework in which they compatibly reinforce each other. Example elements of this agenda include value-based requirements engineering, architecting, design and development, verification and validation, planning and control, risk management, quality management, and people management. It presents seven key elements that provide candidate foundations for value-based software engineering: Benefits Realization Analysis; Stakeholder Value Proposition Elicitation and Reconciliation; Business Case Analysis; Continuous Risk and Opportunity Management; Concurrent System and Software Engineering; Value-Based Monitoring and Control; and Change as Opportunity.
A novel web application frame developed by MVC
Authors: GuangChun Luo , Lu WangYanhua , Hanhong Xianliang
Published: July 2004

The MVC (Model/View/Controller) design pattern was developed in Smalltalk-80 and widely used in software design. This paper introduces a novel Web application frame based on MVC. This frame separates the transaction logic from the presentation format. It also improves the system maintain-ability, scalability and performance by using the module data-base, template database, messaging object and buffer queue.
Enterprise modeling by means of UML instance models
Authors: Torchiano Marco , Bruno Giorgio
Published: July 2004

UML is a widespread software modeling language. It can be a good candidate for modeling non-software systems, such as enterprise systems. While several proposals have been formulated, they are either incomplete or complex. In this paper we propose a modeling approach that is based on the basic object-orientation concepts. In particular we stress the use of instance models as a key concept. The enterprise domain is considered throughout the paper as a meaningful case.
The Software Life Cycle Support Environment (SLCSE): a computer based framework for developing software systems
Authors: Strelich Tom
Published: July 2004

The Software Life Cycle Support Environment (SLCSE) is a VAX/VMS-based software development environment framework which presents a common and consistent user interface accessing a comprehensive set of software development tools supporting the full spectrum of DOD-STD-2 167A software life cycle activities from Requirements Analysis to Maintenance. These tools utilize a Project Database which maintains information relevant not only to the software under development (e.g., requirements allocation, software interfaces, etc.), but also information relating to the project as a whole (e.g., schedules, milestones, Quality Assurance, Configuration Management, etc.). The Project Database supports the DOD-STD-2167A life cycle model and associated Data Item Descriptions (DIDs). SLCSE's framework approach supports the integration of new tools into the environment and permits the SLCSE to evolve over time and adapt to advances in software engineering technology.
(ISEF): an integrated industrial-strength software engineering framework
Authors: Koenig Shaye
Published: July 2004

ISEF is an environment for programming-in-the-large that integrates disparate software engineering principles, methods and tools into an industrial-strength, automated software development framework. Projects using ISEF have reported increased software quality, improved software manageability and decreased software production costs. This paper presents the basic principles and mechanisms that enable ISEF to achieve environment/process integration as well as integration within the environment itself, describes the ISEF approach to software development, provides comparisons with related work, and reports on experience in using ISEF.
A software development environment for law-governed systems
Authors: Minsky Naftaly H. , Rozenshtein David
Published: July 2004

This paper describes a software development environment based on a new approach for managing large-scale evolving systems. Under this approach, the conventional notion of a
system
is augmented with a new component called the
law of the system
, which is an
explicit
and
strictly enforced
set of rules about the operation of the system, about its evolution, and about the evolution of the law itself. The resulting combination is called a
law-governed system.
Interacting with an active, integrated environment
Authors: Rodden Thomas , Sawyer Pete , Sommerville Ian
Published: July 2004

Software engineering environments are intended to provide a cohesive and integrated set of tools to support the process of software engineering with much current research into environment design focussed on maximising the degree to which these tools can be integrated. This paper describes the architecture of a prototype environment which attempts to achieve a high degree of integration using techniques drawn from artificial intelligence, office automation and object-oriented programming. This environment is implemented as a federation of intelligent, co-operating agents which communicate, with each other and with users, by message passing. This paper is particularly concerned with user interface integration including the mechanisms employed to permit inter-agent and agent-user communications.