waashk/dblp huggingface dataset:
the finalization operation for abstract types. in this paper we argue the importance of a finalization capability in a programming language abstract type facility. finalization, the dual of initialization, is crucial for applications involving the allocation of, and access to, abstract resources. a semantic model for finalization is given, defining both statically and dynamically allocated abstract objects, in the presence of exception handling. for illustration, we incorporate finalization in an abstract data type facility designed as an extension of ada.
an engineering methodology for presenting software functional architecture. a method of presenting software architecture has been developed which is useful for reviewing and documenting software designs. diagrams showing all software levels as well as inputs and outputs are systematically developed to provide an understanding of the construction and operation of software systems and programs. the manner in which the software architecture is displayed provides an effective way for managers to understand and review software designs.
a new technique for improving the quality of computer programs. a new rule is proposed for computer systems: every item of data stored by a computer program should subsequently be read; if not, a program must state explicitly whenever it wishes to overwrite or destroy an unused value. this rule is unknown in previous computer systems, yet violations usually indicate a confusing, incorrect or inefficient program. many programming errors also manifest themselves as violations of this rule. the idea has been tested on practical programs by modifying a compiler used at npl. the results are encouraging: when programs are being developed sources of inefficiency are often indicated and many errors show themselves more rapidly. the new rule is no hindrance when writing clear well-structured programs, but confused or obscure programs are more difficult to get (almost!) working. the technique can be implemented in suitably designed hardware very cheaply and easily.
empowering software engineers in human-centered design. usability is about to become the quality measure of today's interactive software including web sites, and mobile appliances. user-centered design approach emerges from this need for developing more usable products. however, interactive systems are still designed and tested by software and computer engineers unfamiliar with ucd and the related usability engineering techniques. while most software developers may have been exposed with basic concepts such as gui design guidelines, few developers are able to understand the human/user-centered design (ucd) toolbox at a level that allows them to incorporate it into the software development lifecycle. this paper describes an approach skilling developers and students enrolled in an engineering program in critical user-centered design techniques and tools. the proposed approach starts from the analysis of the usability and software engineer's work context, identifies critical ucd skills and then associates relevant learning resources with each of the identified skills. our approach suggests a list of patterns for facilitating the integration the ucd skills into the software engineering lifecycle.
monitoring compliance of a software system with its high-level design models. as a complex software system evolves, its implementation tends to diverge from the intended or documented design models. such undesirable deviation makes the system hard to understand, modify and maintain. this paper presents a hybrid computer-assisted approach for confirming that the implementation of a system maintains its expected design models and rules. our approach closely integrates logic-based static analysis and dynamic visualization, providing multiple code views and perspectives. we show that the hybrid technique helps determine design-implementation congruence at various levels of abstraction: concrete rules like coding guidelines, architectural models like design patterns or connectors, and subjective design principles like low coupling and high cohesion. the utility of our approach has been demonstrated in the development of /spl mu/choices, a new multimedia operating system which inherits many design decisions and guidelines learned from experience in the construction and maintenance of its predecessor, choices.
metric-driven analysis and feedback systems for enabling empirically guided software development. the authors summarize the goals of metric-driven analysis and feedback systems and describe a prototype system, amadeus, which defines abstract interfaces and embodies architectural principles for these types of systems. metric-driven analysis and feedback systems enable developers to define empirically guided processes for software development and maintenance. the authors provide an overview of the amadeus system operation, including an example of the empirically guided process, a description of the system characteristics, an explanation of the system conceptual operation, and a summary of the users' view of the system. the centerpiece of the system is a pro-active server, which interprets scripts and coordinates event monitoring and agent activation. amadeus provides an extensible framework for adding new empirically based analysis techniques
tutorial h2: an overview of uml 2.0. this half-day tutorial covers the salient aspects of the first major revision of the unified modeling language, uml 2.0. it includes background information on what drove the requirements and the design rationale---from the point of view of one of its primary designers. the overall structure of uml 2.0 is described followed by a more detailed description of the most prominent new modeling features illustrated with many examples. the ability of uml 2.0 to deal with the needs of model-driven development methods is also covered.
tutorial: an overview of uml 2.0. this half-day tutorial covers the salient aspects of thefirst major revision of the unified modeling language ¿uml 2.0. in this brief summary, we briefly review someof the main points covered in the tutorial.
tutorial: an overview of uml 2. this half-day tutorial covers the salient features of the first major revision of the unified modeling language - uml 2. this short note summarizes the major topics covered by the tutorial.
describing software architecture with uml. the presence of a solid architectural vision is a key discriminator in the success or failure of a software project. this tutorial examines what software architecture is and what it is not. it discusses and illustrates how to describe architecture through a set of design viewpoints and views and how to express these views in the uml [1], in the spirit of the new ieee standard: recommended practice for architectural description [2]. the tutorial shows of how architectures drive the development process and how to capture architectural design patterns using the uml. it is illustrated by several widely applicable architectural patterns in different domain.
efficient decentralized monitoring of safety in distributed systems. we describe an efficient decentralized monitoring algorithm that monitors a distributed program's execution to check for violations of safety properties. the monitoring is based om formulae written in pt-dtl, a variant of past time linear temporal logic that we define. pt-dtl is suitable for expressing temporal properties of distributed systems. specifically, the formulae of pt-dtl are relative to a particular process and are interpreted over a projection of the trace of global states that represents what that process is aware of. a formula relative to one process may refer to other processes' local states through remote expressions and remote formulae. in order to correctly evaluate remote expressions, we introduce the notion of knowledge vector and provide an algorithm which keeps a process aware of other processes' local states that can affect the validity of a monitored pt-dtl formula. both the logic and the monitoring algorithm are illustrated through a number of examples. finally, we describe our implementation of the algorithm in a tool called diana.
a research agenda for distributed software development. in recent years, a number of business reasons have caused software development to become increasingly distributed. remote development of software offers several advantages, but it is also fraught with challenges. in this paper, we report on our study of distributed software development that helped shape a research agenda for this field. our study has identified four areas where important research questions need to be addressed to make distributed development more effective. these areas are: collaborative software tools, knowledge acquisition and management, testing in a distributed set-up and process and metrics issues. we present a brief summary of related research in each of these areas, and also outline open research issues.
interform: a cad system for program development. based on a theoretical approach, we tried to implement a system for assistance to a programmer during the most difficult phase of the programming activity: software design. as we carried out the system project, it become apparent that the system could encompass more than just program design. in the paper, the main ideas of the theoretical approach are outlined. briefly described is the state-oriented architecture of the system. the system structure is also presented.
an effective layout adaptation technique for a graphical modeling tool. editing graphic models always entails layout problems. inserting and deleting items requires tedious manual work for shifting existing items and rearranging the diagram layout. hence, techniques that automatically expand a diagram when space is required for insertion and contract it when free space becomes avaliable are highly desirable.existing layout generation algorithms are no good solution for that problem: they may completely rearrange a diagram after an editing operation, while users want to preserve the overall visual appearance of a diagram.we have developed a technique which automatically expands or contracts a diagram layout when items are inserted or removed while preserving its overall shape, i.e. the positions of the items relative to each other. our technique has been implemented in a prototype tool. we are using it not just for simplifying editing, but primarily for implementing an aspect-oriented visualization concept.
dat flow, abstraction levels and specifications for communications switching systems. the purpose of this effort was the specification and design of a family of communications switching systems, such that each design and implementation of the specification leads to a family member. each set of design and implementation decisions chosen would lead to some appropriate desired member of the family. basically, our methodology consists of the following six steps, system modelling, data flow modelling, features selection, modules selection, hierarchicalization, and abstract machines specification.
modeling of component based systems. component based software development (cbsd) becomes a popular paradigm for internet based systems. compared to other popular paradigms, cbsd supports the development from reusable components other than the development from the scratch. consequently, modeling becomes more important than programming and the modeling techniques in traditional paradigms have to be changed more or less. particularly, improper selection and misuse of modeling techniques would prevent the target system from benefiting from cbsd and even make the project fail. for helping researchers and practitioners to equip with cbsd, this tutorial will provide basic knowledge and skill of modeling component based systems systematically. firstly, we will introduce the technical and non-technical motivations of cbsd with emphasis on software reuse which puts a significant impact on modeling. secondly, we will present a systematic approach to modeling component based systems with a set of existing well-proved modeling techniques, including feature modeling for requirements specification, architecture modeling for abstract design, and object oriented modeling for detailed design. these modeling techniques and a real-life project will be discussed in details in the rest of the tutorial.
a knowledge base for supporting and intelligent program editor. this paper presents work in progress towards a program development and maintenance aid called the intelligent program editor (ipe), which applies artificial intelligence techniques to the task of manipulating and analyzing programs. the ipe is a knowledge based tool: it gains its power by explicitly representing textual, syntactic, and many of the semantic (meaning related) and pragmatic (application oriented) structures in programs. to demonstrate this approach, we implement a subset of this knowledge base, and a search mechanism called the program reference language (prl), which is able to locate portions of programs based on a description provided by a user. this research was supported by the air force office of scientific research under contract f49620-81-c-0067, the office of naval research under contract n00014-82-c-0119, and rome air development center under contract f30602-80-c-0176.
an interactive multimedia software house simulation for postgraduate software engineers. the open university's m880 software engineering is a postgraduate distance education course aimed at software professionals. the case study element of the course (approximately 100 hours of study) is presented through an innovative interactive multimedia simulation of a software house open software solutions (oss). the student 'joins' oss as an employee and performs various tasks as a member of the company's project teams. the course is now in its sixth presentation and has been studied by over 1500 students. in this paper, we present the background to the development, and a description of the environment and student tasks.
the coming-of-age of software architecture research. over the past decade, software architecture research has emerged as the principled study of the overall structure of software systems, especially the relations among subsystems and components. from its roots in qualitative descriptions of useful system organizations, software architecture has matured to encompass broad explorations of notations, tools, and analysis techniques. whereas initially the research area interpreted software practice, it now offers concrete guidance for complex software design and development. we can understand the evolution and prospects of software architecture research by examining the research paradigms used to establish its results. these are, for the most part, the paradigms of software engineering. we advance our fundamental understanding by posing research questions of several kinds and applying appropriate research techniques, which differ from one type of problem to another, yield correspondingly different kinds of results, and require different methods of validation. unfortunately, these paradigms are not recognized explicitly and are often not carried out correctly; indeed not all are consistently accepted as valid. this retrospective on a decade-plus of software architecture research examines the maturation of the software architecture research area by tracing the types of research questions and techniques used at various stages. we will see how early qualitative results set the stage for later precision, formality, and automation and how results build up over time. this generates advice to the field and projections about future impact.
procedure calls are the assembly language of software interconnection: connectors deserve first-class status. software designers compose systems from components written in some programming language. they regularly describe systems using abstract patterns and sophisticated relations among components. however, the configuration tools at their disposal restrict them to composition mechanisms directly supported by the programming language. to remedy this lack of expressiveness, we must elevate the relations among components to first-class entities of the system, entitled to their own specifications and abstractions.
deciding what to design: closing a gap in software engineering education. software has jumped "out of the box" - it controls critical systems; it pervades business and commerce; it is embedded in myriad mechanisms; it infuses entertainment, communication, and other activities of everyday life. designs for these applications are constrained not only by traditional considerations of capability and performance but also by economic, business, market, and policy issues and the context of intended use. the diversity of applications requires adaptability in responding to client needs, and the diversity of clients and contexts requires the ability to discriminate among criteria for success.as a result, software designers must also get out of their boxes: in addition to mastering traditional software development skills, they must understand the contextual issues that discriminate good solutions from merely competent ones. current software engineering education, however, remains largely "in the box": it neglects the rich fabric of issues that lie between the client's problem and actual software development. at carnegie mellon we have addressed this major shortcoming with a course that teaches students to understand both the capabilities required by the client and the constraints imposed by the client's context.this paper presents our view of the engineering character of software engineering, describes the content and organization of our new course, reports on our experience from the first three offerings of our course, and suggests ways to adapt our course for other educational settings.
an efficient set of software degree programs for one domain. there is increasing urgency to put software engineering (se) programs in place at universities in north america. for years, the computer science and professional engineering communities neglected the area, but both are now paying serious attention. there is creative tension as efforts accelerate to define the field faster than is possible. this paper discusses a set of four software degree programs that have evolved over 14 years at a small university with close ties to one software community. the context is computer engineering in a department of electrical and computer engineering, so the natural domain is software that is close to the hardware. this means an emphasis on real-time, embedded, and, to a lesser extent, safety critical issues. the newest of the four programs is a ph.d. program. it demonstrates that ph.d. programs can be created with limited resources, given the right circumstances. if similar circumstances exist in other small universities, the rate of ph.d. production in software engineering may be able to be increased, while maintaining quality. this paper describes the four degree programs, how they are related to each other, and how the programs have evolved. it makes limited comparisons to programs at other universities.
how to do inspections when there is no time. the concepts of inspection are presented, organized around the three ms of inspection (management, mechanics and metrics). fundamentally, inspection provides a way of observing and quantifying software processes while improving software quality. it can be used as a statistical quality control technique for software production. the tutorial addresses variations in inspection processes and techniques, and presents recent research results that investigate which variations are more effective than others. this is done with recognition of the need to adapt inspection approaches to fit local circumstances.
the effects of symbology and spatial arrangement on the comprehension of software specifications. seventy-two participants were presented with specifications for each of three modular-sized computer programs. nine different specification formats were prepared for each program. these formats varied along two dimensions: type of symbology and spatial arrangement. the type of symbology included natural language, constrained language (pdl), and ideograms (flowchart symbols). the spatial arrangement included sequential, branching, and hierarchical versions. the participants answered a series of comprehension questions on each program using only the program specifications. three types of questions were presented: forward-tracing, backward-tracing, and input-output. both forward- and backward-tracing questions were answered more quickly from specifications presented in pdl or ideograms than in natural language. forward-tracing questions were answered most quickly from a branching arrangement, and backward-tracing questions were answered more quickly from branching and hierarchical arrangements. response times to the input-output questions did not vary significantly as a function of the type of symbology or the spatial arrangement.
effort estimation using analogy. the staff resources or effort required for a software project are notoriously difficult to estimate in advance. to date most work has focused upon algorithmic cost models such as cocomo and function points. these can suffer from the disadvantage of the need to calibrate the model to each individual measurement environment coupled with very variable accuracy levels even after calibration. an alternative approach is to use analogy for estimation. we demonstrate that this method has considerable promise in that we show it to out perform traditional algorithmic methods for six different datasets. a disadvantage of estimation by analogy is that it requires a considerable amount of computation. the paper describes an automated environment known as angel that supports the collection, storage and identification of the most analogous projects in order to estimate the effort for a new project. angel is based upon the minimisation of euclidean distance in n-dimensional space. the software is flexible and can deal with differing datasets both in terms of the number of observations (projects) and in the variables collected. our analogy approach is evaluated with six distinct datasets drawn from a range of different environments and is found to outperform other methods. it is widely accepted that effective software effort estimation demands more than one technique. we have shown that estimating by analogy is a candidate technique and that with the aid of an automated environment is an eminently practical technique.
will earlier projects plus a disciplined process enforce se principles throughout the cs curriculum? this paper discusses two related challenges faced by software engineering instructors. first, assuming that projects are necessary to produce successful computer science majors, what should be the role of projects and how best do we integrate theory and application? second, what life cycle models and associated processes should students have the opportunity to experience, and where in the curriculum should a disciplined process first appear? we review several curriculum plans that have been employed to address these problems. we also offer recommendations based on our experiences both with undergraduate computer science majors and with high school students in project tri-p-lets, where beginning programming students are taught to develop games and software simulations following a process.