bluuebunny/crossref_metadata_2025 huggingface dataset:
Performance of publish/subscribe middleware in mobile wireless networks
Authors: Farooq Umar , Parsons Eric W. , Majumdar Shikharesh
Published: July 2004

Publish/subscribe middlewares are becoming popular for distributed applications because of their flexible and scalable nature. Anonymous and loosely-coupled communication between publisher and subscriber, along with the inherently asynchronous nature of these systems, help them adapt quickly to changing environments, making them a good choice for mobile cellular networks. This paper studies publish/subscribe middleware performance in such networks in detail. As a first step, the paper characterizes a popular implementation of publish/subscribe system for the mobile domain, studying and analyzing the effect of different mobility parameters, which to the best of our knowledge is the first experimental research on the performance behavior of publish/subscribe systems in a mobile wireless domain. As a second step the paper presents the design, implementation and evaluation of middleware level handoffs, a well known solution to extend publish/subscribe systems to a mobile domain, and identifies the performance concerns of such extensions. The results show that such handoff protocols involving two brokers are impractical from a performance perspective under highly dynamic and unreliable mobile wireless settings. The paper identifies the basic reason for the limitations of middleware level handoffs.
Performance modeling from software components
Authors: Wu Xiuping , Woodside Murray
Published: July 2004

When software products are assembled from pre-defined components, performance prediction should be based on the components also. This supports rapid model-building, using previously calibrated sub-models or "performance components", in sync with the construction of the product. The specification of a performance component must be tied closely to the software component specification, but it also includes performance related parameters (describing workload characteristics and demands), and it abstracts the behaviour of the component in various ways (for reasons related to practical factors in performance analysis). A useful set of abstractions and parameters are already defined for layered performance modeling. This work extends them to accommodate software components, using a new XML-based language called Component-Based Modeling Language (CBML). With CBML, compatible components can be inserted into slots provided in a hierarchical component specification based on the UML component model.
Intelligent agents in E-learning
Authors: Agarwal Rakesh , Deo Amrita , Das Swati
Published: July 2004

In this competitive era, education has become equally demanding and competitive. Innovation in the sphere of education has led to new ways of learning. Internet has now made learning dynamic by introducing the concept of learning through E-learning. The dynamism in E-Learning can be made more powerful with the help of intelligent agents. Intelligent, autonomous, mobile, rational, reactive, persistent and moreover proactive computer code so called as agents represent the next tidal wave of innovation and development in the Information age. These agents perform specific tasks on the behalf of students, instructors, and other members of the educational community including parents and alumni. The agent-based technology is expected to have an effect as profound and lasting as the World Wide Web. It is growing to be a continuously evolving and expanding area. The paper focuses on the use of intelligent agents in the sphere of effective E-learning education.
Few important considerations for deriving interface complexity metric for component-based systems
Authors: Gill Nasib S. , Grover P. S.
Published: July 2004

Component-based software engineering (CBSE) represents an exciting and promising paradigm for software development. Software components are one of the key issues in CBSE. The software development community is continuously seeking new methods for improving software quality and enhancing development productivity. There is an increasing need for component-based metrics to help manage and foster quality in component-based software development. The traditional software product and process metrics are neither suitable nor sufficient in measuring the complexity of software components, which ultimately is necessary for quality and productivity improvement within organisations adopting CBSE. In this paper, we propose an interface complexity metric (ICM) aimed at measuring the complexity of a software component based on the interface characterisation model of a software component that mainly include such as interface signature, interface constraints, interface packaging and configurations. Based on the value of this metric, the complexity of the software component could be managed within reasonable complexity limits. In this way, the software components could be kept simple which in turn help in enhancing the quality and productivity.
A neural net based approach to Test Oracle
Authors: Aggarwal K. K. , Singh Yogesh , Kaur A. , Sangwan O. P.
Published: July 2004

In this paper an attempt has been made to explore the possibility of the usage of artificial neural networks as Test Oracle. The triangle classification problem has been used as a case study. Results for the usage of unsupervised artificial networks indicate that they are not suitable for this purpose. The Feed-forward back propagation neural networks are demonstrated to be suitable.
π-ADL
Authors: Oquendo Flavio
Published: July 2004

A key aspect of the design of any software system is its architecture. An architecture description, from a runtime perspective, should provide a formal specification of the architecture in terms of components and connectors and how they are composed together. Further, a dynamic or mobile architecture description must provide a specification of how the architecture of the software system can change at runtime. Enabling specification of dynamic and mobile architectures is a large challenge for an Architecture Description Language (ADL). This article describes π-ADL, a novel ADL that has been designed in the ArchWare European Project to address specification of dynamic and mobile architectures. It is a formal, well-founded theoretically language based on the higher-order typed π-calculus. While most ADLs focus on describing software architectures from a structural viewpoint, π-ADL focuses on formally describing architectures encompassing both the structural and behavioural viewpoints. The π-ADL design principles, concepts and notation are presented. How π-ADL can be used for specifying static, dynamic and mobile architectures is illustrated through case studies. The π-ADL toolset is outlined.
XS-0
Authors: Nievergelt J. , Frei H. P. , Burkhart H. , Jacobi C. , Pattner B. , Sugaya H. , Weibel B. , Weydert J.
Published: July 2004

XS-0 is a low-cost interactive system that serves as a self-explanatory school computer. Particular attention has been devoted to making the man-machine dialog easy to follow for the inexperienced user. The system includes a course on computer programming, a programming system for writing, editing, executing, and debugging programs interactively, and a filing system containing private and public libraries. The language offered to the user is a version of Pascal. The system is realized on a small stand-alone computer which supports a small number of graphic terminals. This hardware consists of the most cost effective components currently on the market.
A survey of faculty computer experience, usage, needs, literacy and attitudes
Authors: Wainwright Roger
Published: July 2004

The faculty were surveyed concerning their computing experience, usage, needs and attitudes. The respondents were divided into two groups, users and non-users of computing facilities. Responses concerning computers in curriculum and computer attitudes in general were compared between the two groups. Statistical tests show significant differences in opinions between the two groups on various subjects. Results of the survey on computer usage, experience and needs from the users group is also reported in this paper.
The little language compiler course project
Authors: van de Riet R. P.
Published: July 2004

This paper describes a project for a course in compiler construction meeting three constraints: (1) the project should start immediately at the beginning of the summer course being compressed to six weeks, five days a week; (2) one language had to be chosen that was understandable to students of different backgrounds and programming experience and suitable as a vehicle in making algorithms for compiler design; (3) the project should help in making well-structured programs.
Teaching and learning computer programming
Authors: Ulloa Miguel
Published: July 2004

To improve introductory computer science courses and to update the teaching of computer programming, new teaching methods emphasizing structured programming and top-down design have been presented and a variety of automated instructional tools have been developed. The purpose of this paper is: (1) to survey a number of methods and tools used in the teaching of programming; (2) to present, with the aid of this survey, a number of areas where beginning programmers experience difficulties; (3) to present ways of improving some of the tools; and (4) to propose other possible aids.This paper is organized as follows. Section 1 introduces the topic and purpose of the paper. Section 2 reviews several teaching methods discussed in the literature. Section 3 surveys various student-oriented interactive and noninteractive tools. Section 4 discusses nonstudent-oriented aids and presents alternatives by discussing how to adapt similar aids to a student environment. Section 5 provides a summary of the paper and a conclusion. Pertinent problem areas and students' viewpoints are presented in each section.
A simulator for teaching computer architecture
Authors: Kerridge J. M. , Willis N.
Published: July 2004

This paper describes the specification, implementation and use of a computer system simulator. The simulator project was begun as a result of teaching a second year undergraduate course in computer systems.It became apparent that students only fully appreciate the differences in computer architecture when they are able to have "hands on" experience. This simulator, which operates at the register transfer level, allows students to gain experience of many different architectures without recourse to many different computers. This experience, in the first instance, is gained by the students being able to run programs on the simulated computers and then investigating the state of the computer after each machine or micro instruction. The design of these teaching computers is chosen so that they demonstrate a particular architectural detail. Subsequently students can design their own computer systems and compare them with simulations of commercially available computers.
Software engineering for undergraduates
Authors: Carver Doris L.
Published: July 2004

Software engineering has become one of the fastest growing fields in computer technology due to the increasing cost of software development. Software engineering courses have been placed in many undergraduate Computer Science curriculums. This paper describes a project approach to teaching undergraduate software engineering where each group developed the same project. Advantages and disadvantages of the one-project approach based on the students' and the instructor's evaluation are discussed.
A visible assembler for a course in introductory system software
Authors: Ezell Cloyd
Published: July 2004

Ideas from program visualization have been borrowed to create an assembler that reveals its operations as it executes. This assembler is used as an object of study in an introductory course in system software.
Chinese Rings and recursion
Authors: Early Grady G. , Stanat Donald F.
Published: July 2004

The Chinese Rings puzzle is used as a vehicle to convey the power and subtlety of recursion in a way understandable by students in a second programming course. An elegant algorithm incorporating two mutually recursive subroutines is presented and analyzed.
Continuity of student software development in tertiary institutions
Authors: Dunstan Neil
Published: July 2004

Despite the availability and professional use of programming productivity aids and techniques, instruction in their use seems to be absent from tertiary computer programming courses. This is partly because the student programming environment in tertiary institutions lacks the continuity of software development normally found in the real world of professional computer programming. A greater emphasis on this aspect of computer programming, and the ways and means that may be employed, would better acquaint our computer programming students with their probable working environment and make the good programming practices which are currently taught, more relevant to the students.
COMES
Authors: Manzo M. Di , Ferraris M. , Frisiani A. L. , Midoro V. , Olimpo G.
Published: July 2004

COMES, a system for computer aided instruction oriented to programming languages, is described here. The system allows a full integration of theory learning and practical applications since it offers two different teaching strategies, one corresponding to a purely tutorial environment and one to a programming and problem-solving environment that has to be specialized for a given programming language. Thus, the learning process can be based on a tight alternation of theory and practice and relies more on personal experience than on memorization of abstract information. The main design choices are discussed in the paper and two examples of dialogues are supplied.
A survey of graduates from an undergraduate computer science program
Authors: Homeyer Fred C.
Published: July 2004

A survey of the computer science graduates at Angelo State University was conducted in May, 1977. Data was gathered concerning starting salary, current salary, job satisfaction, job location and job duties. The computer science program at Angelo State University was established in 1970 and since that time, 37 students have obtained undergraduate computer science degrees.Two degree programs in computer science are offered at Angelo State. The Bachelor of Science degree is designed to prepare students for further study in computer science and is tailored to students interested in the scientific aspects and applications of computing. Advanced undergraduate courses in this degree program prepare a student for employment as a systems programmer or software specialist. The Bachelor of Business Administration degree emphasizes commercial or business data processing applications and is designed to prepare students to enter the job market as business programmers or computer center managers.The data obtained from the survey was summarized for all computer science graduates and then considered separately for the Bachelor of Science graduates and then the Bachelor of Business Administration graduates. It was determined that the average starting salary for all graduates was $11,809 and the average current salary is $14,403. The average starting salary for Bachelor of Science graduates was $12,500 while the current average salary for Bachelor of Science graduates is $15,550. The Bachelor of Business Administration graduates received an average starting salary of $10,600 and have a current average salary of $12,395. The data obtained from the survey has also been analyzed according to the different industries in which the graduates are employed and in terms of the geographical location of their employment. While the results obtained from this survey are for a single small school, some generalizations can be made concerning the success of an undergraduate computer science curriculum that has been established according to the "Curriculum '68" guidelines.Much can be learned from surveying our computer science graduates. The valuable information that our graduates give us can do much to enhance and improve the computer science curriculum. This information can also do much to keep our current students informed as to what to expect in the marketplace.
A graduate immigration course in computer science
Authors: Chanon R. N.
Published: July 2004

As part of a RIAS grant from the NSF, a pilot course intended for incoming graduate students in computer science was offered during the fall of 1977. This course was intended to acquaint new graduate students with (1) the CS graduate curriculum and degree requirements; (2) the areas of CS faculty interest, research, and support; (3) current areas of research in CS; and (4) the computing facilities available through the UT Computation Center and the department's software laboratory. These goals were realized through regular lectures, several programming problems and ten lectures from different faculty members about their research interests and current work. Specific assignments for each student were determined on the basis of their backgrounds and interests. (A questionnaire answered during the first lecture helped to determine these.) An important part of the course involved about twelve lectures citing widely applicable topics from the first three volumes of The Art of Computer Programming, by D. E. Knuth.This course is believed to be a valuable asset to the department's curriculum because of the diverse nature of its faculty, computing facilities, and graduate students.
Teaching toward error free programming
Authors: McCurdy Robert
Published: July 2004

A newly developed teaching technique designed to help students produce error free code using a block-structured flowcharting method, a block-structured pseudocode, and an implementation language is presented [1]. The posters illustrate how block structure, once established, is maintained in the pseudocode and into an implementation language. The flowcharting method was developed at Draper Labs in connection with the Apollo Program [2].
Structured programming for computer science majors
Authors: Omlor J. Dennis
Published: July 2004

Computer Science majors come from various interdisciplinary backgrounds. Some have had programming jobs in industry; others are just normal students following a normal course schedule. Teaching students, with various educational and job backgrounds, presents problems of a technical and a personal nature. Structured programming with its incumbent radicalism is not normal for either group, and is not readily accepted by either group. Both groups view it with suspicion.An instructor's job is to alleviate confusion by showing students how to accomplish this technique. He also has a responsibility to set programming standards and enforce them strictly. In addition, he has the obligation of verifying the readability and maintainability of student programs. The programming classroom shouldn't solely be a problem solving class; it should stress and demand these other aforementioned features.This tutorial will stress technical aspects of structured programming, enforcing standards, verifying readability, and making students realize the importance of deadlines.
Industrial needs culminated in business applications course
Authors: Schrage John F.
Published: July 2004

Commercial Systems Applications introduces the student to data processing principles and practices as related to computer-oriented systems. Data processing, business, and communication skills are brought together to produce research into organizations and their applications.
Cooperative education and realistic student preparation
Authors: Arnow Barry
Published: July 2004

Most existing EDP Programs do not maintain the close coordination with industry required to keep programs relevant and up to date. As a result, students, unprepared for the sophisticated problems they encounter in industry often must struggle to make the formidable adjustment required. Cooperative education programs which attempt to coordinate classroom instruction with on the job training have in many cases not realized their potential because the student's academic training is too unrealistic to be of significant help on the job. Our efforts in the classroom must be directed towards preparing students to deal with the demands that will be made on them as professionals in the computer field. Emphasis must be placed on teaching students methods and techniques for solving their own problems rather than mearly conveying facts and information. A suggested method for conveying the realism of industry in the classroom is to replace the traditional student-teacher relationship with one of employee-supervisor. Students working on individual projects hold private meetings with the instructor in place of class lectures. The complete design, programming, documentation and oral presentation of a worthy EDP Project becomes the total responsibility of the student with the advice and guidance of the instructor. Companies participating in the coop program may also be given the opportunity to suggest projects. In addition to allowing a potential coop student to gain some familiarity with an employers needs, it conveys a desire on the part of the school to keep programs sensitive to the needs and changes in industry. Courses and programs as these which allow for industrial input in our curriculum development are essential to keep pace with the rapid growth and changes that characterize this dynamic field.
The integration of a traditional cooperative education program and a computer science discipline
Authors: Foutz Patricia Bartos , Johnson Martha J.
Published: July 2004

The Cooperative Education (CO-OP) Program at Virginia Polytechnic Institute and State University (VPI&SU) and its impact in a Computer Science (CS) discipline are described. CO-OP certification and a comparison of the academic performance of the CO-OPing student and the non-CO-OPing student are discussed. In particular, the CS CO-OP students' attitudes on the program and their acquisition of knowledge outside the traditional classroom environment are presented. Options for earning academic credit in computer science, the growth of CO-OPing in computer science, and the typical job assignments and monetary compensation are also included.
Cooperative education
Authors: Hatfield Frank J. , Alexander Roberta R.
Published: July 2004

Students, employers and colleges participate in cooperative education to gain specific benefits. Success is achieved only if all the participants meet their individual objectives. The day-to-day activities and decisions of the cooperative education faculty must make this possible.
Programming languages for introductory computing courses
Authors: Solntseff N.
Published: July 2004

This paper examines the question of the programming language to be used in introductory computing courses. It is found that there are three distinct groups of students that have to be catered for in introductory courses: the "casual user", the "general user", and the "professional user". The manner in which the introductory courses fit into the student's curriculum are examined next and an analogy is developed between "structured programming" and teaching. This analogy is used to draw conclusions concerning the descriptive properties of the pedagogic language to be used. Issues concerning the modularity of both data and procedure structures are reviewed and the emergence of programming languages specifically designed to enhance their descriptive powers in this area is noted. It is concluded that there is a need for a pedagogic language that can be used in all courses in which the computer is an object of study and that the most commonly used languages, namely, FORTRAN and PL/I fail to meet the requirements deduced in this paper. At the present time, Pascal is the only widely known language that can be considered for this role.
A graduate program in information systems for the Lating American environment
Authors: Mijares C. Ignacio
Published: July 2004

Before designing a graduate program in information - systems it is important to consider the characteristics of the potential students and the characteristics of the environment in which these students are expected to work after graduating. Since most of the published work in this field has been done in developed countries, it is specially important to consider the implications that may arise when designing education programs for underdeveloped countries. A brief profile of the Latin American environment is presented here together with a graduate program designed for such environment.
Hardware laboratories
Authors: Holland Robert , Fulton David , Lamie Ed , Nagy George , Tartar John , Wienkam Jay
Published: July 2004

Computer systems technology today has become so complex that a mere lecture style of teaching is no longer a viable means of instruction. Professionals in the field must have a strong familiarity with hardware devices, systems design concepts, data base techniques, and telecommunications. Many feel that students can only learn these techniques through integrated laboratory assignments. Thus, one of the major thrusts in computer science today is the establishment of a laboratory learning environment in which students work independently and in teams to solve various types of integrated design problems.This panel session is dedicated to a discussion of the types of hardware, their application in the teaching of computer and information sciences, and methods for acquiring the necessary equipment. The panelists for this discussion have either established or are in the process of establishing a computer laboratory. Each panelist will describe their approach to the computer laboratory design, the purposes for which the equipment is to be used, student and faculty reaction to the usage of the lab, and administrative problems associated with implementing and operating a computer laboratory.
Computer science education in developing countries
Authors: Sterling Theodor , Allotey F. K. , Khailany Asad , Lisboa Maria Lucia Blanck , Mijares Ignacio , Robertson Edward
Published: July 2004

The December, 1977 issue of the Communications of the ACM, in the Forum section, describes a situation in North Africa and the Middle East where a programmer must have command of the English language besides programming skills. That situation appears to hold for all developing nations. But this necessity, created because software is based on the English language, may have these disadvantages:1) Programming is problem solving and forcing a programmer to think in a language that is not native to him, in which he does not think fluently, creates another obstacle to good programming.2) The number of available technicians are seriously limited to those individuals in a developing country who speak English or at least enough of that language to qualify for a position. A large number of "people" resources are disqualified in this way.The panel will address itself to these two assertions. Sufficient time will be given as well for audience participation. Especially welcome will be information concerning the actual use of programming languages which are not based on English grammar and vocabulary.
Conducting project team classes in data processing
Authors: Khailany Asad , Saxon Charles
Published: July 2004

In screening and evaluating the background of applicants for careers in data processing, a considerable emphasis is placed on the ability of the applicant to work as a member of a team. This is because many required skills in data processing, specifically in the commercial environment, can only be obtained through individual work as a member of a team. This paper focuses on a method for simulating the business data processing environment through class project teams. The simulation is demonstrated through a discussion of the process of selecting the teams and projects, the frequent problems faced by team members, the background knowledge required, and the methods used in evaluating the projects.The benefits that can be derived by taking the programming team approach to the design and implementation of computer systems have been widely discussed in the literature [1, 2, 3]. This approach is receiving increasing attention in the commercial environment [4]. In addition, several new system design techniques [5, 6, 7, 8, 9] are becoming increasingly popular and the ideas of structured programming [10, 11, 12] are widely known. We feel, therefore, that an important part of the preparation for a career in information processing should include participation as a member of a programming and design team.In this paper we demonstrate the methods that we have used to create a project team environment in the classroom. These methods are based on our commercial experience and experience gained from conducting such classes for a combined total of seven semesters. Overall, the projects resulting from these team efforts have been of high quality and the students' reactions have been very favorable. The students from these courses that sought careers in data processing were able to find jobs rapidly. They have been highly successful in their careers.In interviews with our graduates they indicated that the experiences they gained from the project team classes were main factors in obtaining employment and the success they achieved in their work.
A student group project in operating system implementation
Authors: Comaa H. , Kramer J. , Penney B. K.
Published: July 2004

A student operating system project is described. It provides students, working in groups of 4 or 5, with some insight into the design and organisation problems of constructing a fairly large and complex piece of software. The students design and implement the Nucleus of a multiprogramming system which runs under the control of a VM/CMS virtual machine, Aspects of the project structure and its organisation are discussed.
A course in programming and practice
Authors: Chanon R. N.
Published: July 2004

Numerous books and papers discuss approaches for solving problems that arise when software systems are built. Many of these, however, describe methods that seem reasonable only to experienced designers and programmers. To many, these problems often seem unmotivated, especially among students who have only written small programs. This paper describes a programming course intended to teach such students some of the more popular software engineering guidelines and approaches.
The use of interactive fortran
Authors: Mazlack Lawrence J.
Published: July 2004

An experiment was conducted to examine the utility of conducting an intensively mathematical FORTRAN program course by the use of interactive terminals. IBM'S TSO operating system was the chosen vehicle. In addition to text editing, students were required to gain as much FORTRAN knowledge as before. It was found that students at the lower end of the class did better. In addition, there were fewer student withdrawals from the class. Lastly, interactive skills were used in following classes.
Why johny can't program
Authors: Leither Henry E. , Lewis Harry R.
Published: July 2004

We are engaged in teaching technical material, specifically computer science, to a large number of undergraduates (400--500), the majority of whom are non-science majors.Many of these students have trouble learning the course material. We are not here talking about those few students who are affected by such problems as physical handicaps or other specific learning disabilities; non are we concerned with those individuals who exhibit poor study habits or strong preferences for unusual "favored modes of perception" [WEIN]. We are concerned with the significant number of students who, for no apparent reason, have a great deal of difficuly learning elementary computer concepts. Why do some never understand? Why do others, who eventually succeed, take a great deal longer than the majority of our students?This paper is a report on research in progress. Our research at this time is mainly concerned with:(a) Determining, in advance, which students are likely to encounter the severest problems learning computer science;(b) Finding out what there is specifically in the nature of the course material which causes the greatest difficulty for these students; and(c) Developing a methodology for helping students to overcome such learning problems.This paper is organized into 6 major sections.Section I is an introduction to the Natural Sciences 110 course, to the programming language used in this course, and to the major teaching problems we face.Section II is a statement of our goals in this research effort.Section III describes the method by which we are attempting to realize our intended goals.Section IV describes the special recitation sections which are being used to help us monitor the potentially "slower" students.Section V deals with classifying the specific conceptual barriers which we have thus far found to inhibit normal learning in many computer science students.Section VI is 2 statement of the direction which our research will follow in the immediate future.
Small systems for undergraduate courses in system design
Authors: Grillo John P.
Published: July 2004

This paper discusses the problem of finding an appropriate target system for undergraduate system design classes. This system should allow the students to experience its life cycle, including full implementation through the programming and installations phases. The system case is chosen to be purposely small and immediately useful. The implementation language used is an extended BASIC, which greatly facilitates file manipulation and interactive programming. The system is designed to be menu-driven; that is, its activities are selected by the user from a menu display. Two specific implementations of such a system are described. One is in a small business, and the other is in a college classroom setting.
A project to teach microprogrammed asynchronous system design
Authors: Vishnubhotla Sarma R.
Published: July 2004

Teaching courses in logic and systems design is not complete unless the students are able to design a logic system as a part of their course work. A project on the design of an asynchronous computer system is presented in this paper. This system is microprogrammed and has no master clock to time the micro operations. The computer designed has sixteen machine instructions, 2K core memory, and a microcomputer with 256 word ROM.
A distributed architecture for programming environments
Authors: Clément Dominique
Published: July 2004

Programming environments are typically based on concepts, such as syntax and semantics, and they provide functionalities, such as parsing, editing, type-checking, and compiling. Most existing programming environments are designed in a fully integrated manner, where parsers, editors, and semantic tools are tightly coupled. This leads to systems that are the sum of all their components, with obvious implications in terms of size, reusability, and maintainability. In this paper, we present a proposal for a distributed architecture for programming environments.
An extensible programming environment for Modula-3
Authors: Jordan Mick
Published: July 2004

This paper describes the design and implementation of a practical programming environment for the Modula-3 programming language. The environment is organised around an extensible intermediate representation of programs and makes extensive use of reusable components. The environment is implemented in Modula-3 and exploits some of the novel features of the language.
The Pan language-based editing system for integrated development
Authors: Ballance Robert A. , Graham Susan L. , Van De Vanter Michael L.
Published: July 2004

Powerful editing systems for developing complex software documents are difficult to engineer. Besides requiring efficient incremental algorithms and complex data structures, such editors must integrate smoothly with the other tools in the environment, maintain a sharable database of information concerning the documents being edited, accommodate flexible editing styles, provide a consistent, coherent, and empowering user interface, and support individual variations and project-wide configurations.
Pan
is a language-based editing and browsing system that exhibits these characteristics. This paper surveys the design and engineering of
Pan
, paying particular attention to a number of issues that pervade the system: incremental checking and analysis, information retention in the presence of change, tolerance for errors and anomalies, and extension facilities.
A multi-formalism specification environment
Authors: Ipser Edward A. , Wile David S. , Jacobs Dean
Published: July 2004

This paper describes initial work on a software development environment capable of smoothly integrating modules written in different languages. The focus of this work is on supporting the construction of executable,
multi-formalism specifications
, where each part of a problem is described in a language that is close to its underlying domain. We distinguish specifications from programs to emphasize the closeness of the formalism to these domains rather than underlying computational models, and to indicate that we are not attempting to integrate existing implementations of programming languages. Rather, we provide a grammar-based framework for the construction and integration of
interpreters
for different specification formalisms. The key to our approach is that formalisms communicate through grammatically described
interfaces
. Such interfaces hide incompatible aspects of different formalisms, allowing new combinations of formalisms to be created easily.
Reusing software developments
Authors: Goldberg Allen
Published: July 2004

Software development environments of the future will be characterized by extensive
reuse
of previous work. This paper addresses the issue of
reusability
in the context in which design is achieved by the transformational development of formal specifications into efficient implementations. It explores how an implementation of a modified specification can be realized by
replaying
the transformational derivation of the original and modifying it as required by changes made to the specification. Our approach is to structure derivations using the notion of tactics, and
record derivation histories as an execution trace of the application of tactics
. One key idea is that tactics are compositional: higher level tactics are constructed from more rudimentary using defined control primitives. This is similar to the approach used in LCF[12] and NuPRL[1, 8].

Given such a derivation history and a modified specification, the correspondence problem [21, 20] addresses how during replay a correspondence between program parts of the original and modified program is established.

Our approach uses a combination of name association, structural properties, and associating components to one another by intensional descriptions of objects defined in the transformations themselves.

An implementation of a rudimentary replay mechanism for our interactive development system is described. For example with the system we can first derive a program from a specification that computes some basic statistics such as mean, variance, frequency data, etc. The derivation is about 15 steps; it involves deriving an efficient means of computing frequency data, combining loops and selecting data structures. We can then modify the specification by adding the ability to compute the maximum or mode and replay the steps of the previous derivation.
Fine grained data management to achieve evolution resilience in a software development environment
Authors: Snodgrass Richard , Shannon Karen
Published: July 2004

A software development environment (SDE) exhibits evolution resilience if changes to the SDE do not adversely affect its functionality nor performance, and also do not introduce delays in returning the SDE to an operational state after a change. Evolution resilience is especially difficult to achieve when manipulating fine grained data, which must be tightly bound to the language in which the SDE is implemented to achieve adequate performance. We examine a spectrum of approaches to tool integration that range from high SDE-development-time efficiency to high SDE-execution-time efficiency. We then present a meta-environment, a specific SDE tailored to the development of target SDE's, that supports easy movement of individual tools along this spectrum.
Configuration editing, generation and test within working contexts
Authors: Kobialka Hans-Ulrich
Published: July 2004

In a software development environment any progress is reflected in modifications of design documents. These changes must be attended by recording of versions in order to restore consistent states and to rebuild delivered systems for error detection. The introduction of versions implies the need for version selection mechanisms, to achieve the same degree of operability as known in versionless environments.

This paper introduces a version selection mechanism based on the notion of working contexts. Examples generated by the ADD document management system illustrate how editing, generation and test of configurations are eased using working contexts.
Language constructs for managing change in process-centered environments
Authors: Sutton Stanley M. , Heimbigner Dennis , Osterweil Leon J.
Published: July 2004

Change is pervasive during software development, affecting objects, processes, and environments. In process centered environments, change management can be facilitated by software-process programming, which formalizes the representation of software products and processes using software-process programming languages (SPPLs). To fully realize this goal SPPLs should include constructs that specifically address the problems of change management. These problems include lack of representation of inter-object relationships, weak semantics for inter-object relationships, visibility of implementations, lack of formal representation of software processes, and reliance on programmers to manage change manually.

APPL/A is a prototype SPPL that addresses these problems. APPL/A is an extension to Ada.. The principal extensions include abstract, persistent relations with programmable implementations, relation attributes that may be composite and derived, triggers that react to relation operations, optionally-enforceable predicates on relations, and five composite statements with transaction-like capabilities.

APPL/A relations and triggers are especially important for the problems raised here. Relations enable inter-object relationships to be represented explicitly and derivation dependencies to be maintained automatically. Relation bodies can be programmed to implement alternative storage and computation strategies without affecting users of relation specifications. Triggers can react to changes in relations, automatically propagating data, invoking tools, and performing other change management tasks. Predicates and the transaction-like statements support change management in the face of evolving standards of consistency. Together, these features mitigate many of the problems that complicate change management in software processes and process-centered environments.
Support for change in RPDE
3
Authors: Ossher Harold , Harrison William
Published: July 2004

RPDE
3
is a framework for building environments. Great emphasis has been placed on supporting changes of various kinds, such as extensions to existing environments and creation of new environments by adapting existing environments. We have a three-pronged approach to supporting change: (1) use of a central framework providing key services is a uniform fashion, (2) an extended object-oriented programming paradigm supporting fine-grained changes by addition of small code fragments, and (3) structured representation of program material facilitating sophisticated language-sensitive processing. RPDE
3
has been used on a daily basis for its own development for about three years now, and during that time has undergone extensive change. This experience has indicated strongly that our approach to supporting change is effective, and has identified extensions to it that should make it more effective still. This paper describes the approach and, primarily, our experience.
Integrating configuration management into a generic environment
Authors: Mahler Axel , Lampen Andreas
Published: July 2004

The software development process consists of a number of complex activities for work coordination, organization, communication, and disciplines that are essential for achieving quality software, maintaining system integrity, and keeping the software process manageable. Software Engineering Environments can be helpful instruments in pursuing these goals when they are integrated, open to extension, and capable of adapting to real processes as they occur in software development projects.

Adaptability and the ability to perform adaptations
rapidly
are crucial features of SEEs. In this paper we are presenting an approach to rapid environment extension that provides the means to capture characteristics of software development processes and realize environment support for these processes by using existing tools. An object oriented
environment infrastructure
is the basis for achieving these goals while providing and maintaining an integrated behavior of the environment. The presented approach is demonstrated by defining a set of
classes
for version control and configuration management that model the behavior of an existing configuration management toolkit.
A query service for a software engineering database system
Authors: Tedjini Mohamed , Thomas Ian , Benoliel Guy , Gallo Fernando , Minot Régis
Published: July 2004

The PCTE interfaces define a Public Tool Interface intended to serve as a basis for the construction of integrated software engineering environments (SEEs). The interfaces include Object Management System (OMS) services that manage the data repository of the environment. The OMS is based on a binary Entity-Relationship model.

This paper describes a query service constructed on the PCTE interfaces. Following a brief summary of the OMS features that are necessary to understand the paper, we describe the requirements and design objectives for a query service in an integrated SEE, the basic model for our solution, and then review the facilities of the service. The paper also contains a comparison with other work on queries on E-R and object-oriented databases.

The paper's conclusions indicate the differences that exist between requirements and characteristics for query services on SEE data repositories and those for other databases. It shows, for example, how assumptions about data availability and accessibility that are often made for query services are not appropriate for SEE data repositories.