waashk/dblp huggingface dataset:
data-driven implementation of data flow diagrams. current software engineering methods employ a variety of design notations and techniques during the development process. this paper suggests a new, unified approach to developing software, termed program/system design. programs are viewed as being made up of systems of data-coupled, data-activated processing units. using a coherent hierarchy of data flow diagrams, complex systems are specified as compositions of successively simpler systems. the methods are illustrated by a program/system solution to the telegram problem.
design considerations in language processing tools for ada. the ada language system (als) is a complete programming environment for the development of ada programs. this paper discusses the design objectives of those portions of the als which support translation and execution of ada programs, particularly the compiler, linker, and program library. the als capabilities for maintenance of software configuration control are highlighted. tradeoffs in the design of the compiler phase structure and intermediate languages are presented.
verification system for formal requirements description. the requirements description which is proved to be correct is the key to the successful development of a reliable system. since the adaptability of the requirements description language is obtained with a simple and extensible language structure, most part of communication is maintained with proper use of labels. many verification system can provide only restricted capability because of lack of the recognition of meaning of labels. this paper proposes the verification method with assertion description which gives another view of a target system. first, the formal model of the verification is given. next, the verification method based on theorem proving and several views for verification are mentioned. last, the verification system and examples are shown.
introduction to the attribute driven design method. this tutorial will introduce the attribute driven design (add) method. add is a method for designing the software architecture of a system or collection of systems based on an explicit articulation of the quality attribute goals for the system(s). the method is appropriate for any quality attributes but has been particularly elaborated for the attributes of performance, modifiability, security, reliability/availability and usability. the method has been used for designing the software architecture of products ranging from embedded to information systems.
a fast assembly level reverse execution method via dynamic slicing. one of the most time consuming parts of debugging istrying to locate a bug. in this context, there are two powerfuldebugging aids which shorten debug time considerably:reverse execution and dynamic slicing. reverse executioneliminates the need for repetitive program restartsevery time a bug location is missed. dynamic slicing, onthe other hand, isolates code parts that influence an erroneousvariable at a program point. in this paper, we presentan approach which provides assembly level reverse executionalong a dynamic slice. in this way, a programmer notonly can find the instructions relevant to a bug, but also canobtain runtime values of variables in a dynamic slice whiletraversing the slice backwards in execution history.reverse execution along a dynamic slice skips recoveringunnecessary program state; therefore, it is potentiallyfaster than full-scale reverse execution. the experimentalresults with four different benchmarks show a wide range ofspeedups from 1.3x for a small program with few data inputsto six orders of magnitude (1,928,500x) for 400x400matrix multiply. furthermore, our technique is very memoryefficient. our benchmark measurements show between3.4x and 2240x memory overhead reduction as comparedto our implementation of the same features using traditionalapproaches.
lessons from using basic lotos. we describe three case studies in the use of basic lotos for electronic switching systems software. the studies cover design recovery, requirements specification, and design activities. we also report lessons learned from the studies. early lessons suggested changes to the syntax of the language used, and the need for some specific analysis tools. the last case study reports some of the results of these changes
automatic generation of rule-based software configuration management systems. we propose a model-driven methodology and toolset for automatic scm system repository creation and feature composition using code generation and rule engine technologies.
a quality-driven systematic approach for architecting distributed software applications. architecting distributed software applications is a complex design activity. it involves making decisions about a number of inter-dependent design choices that relate to a range of design concerns. each decision requires selecting among a number of alternatives; each of which impacts differently on various quality attributes. additionally, there are usually a number of stakeholders participating in the decision-making process with different, often conflicting, quality goals, and project constraints, such as cost and schedule. to facilitate the architectural design process, we propose a quantitative quality-driven approach that attempts to find the best possible fit between conflicting stakeholders' quality goals, competing architectural concerns, and project constraints. the approach uses optimization techniques to recommend the optimal candidate architecture. applicability of the proposed approach is assessed using a real system.
enhancing program readability and comprehensibility with tools for program visualization. in order to make computer programs more comprehensible, the presentation of program source text, program documentation, and program execution needs to be enhanced over its conventional treatment. the paper describes a number of new techniques and tools developed to achieve these ends. one of these is a novel design for the effective presentation of source text in the c programming language using high quality digital typography, and a processor which implements the design. some experimental evidence is summarized to demonstrate that the resulting source text presentation is significantly more readable and comprehensible than the presentation conventionally used today. brief descriptions are also given of two other techniques, the development of a novel system of structured program documentation incorporating both text and graphics, and the portrayal of program execution with coloured computer animation.
component-based self-adaptability in peer-to-peer architectures. current peer-to-peer architectures are hardly resistantagainst unanticipated exceptions such as the failure ofsingle peers. this can be justified by the absence of sophisticatedmodels for detecting and handling exceptionin peer-to-peer architectures. on the other hand, existingmodels for such self-adaptable architectures are rathergeneric and less practical for end-users. in this work, acomponent-based self-adaptability model for peer-to-peerarchitectures is presented that supports end-users in thehandling of exceptions during use time. support is alsoprovided to handle exceptions during deployment andadaptation of an application. all these approaches areintegral parts of deevolve, a peer-to-peer runtime environmentfor component-based peer services.
the two-step commitment protocol: modeling, specification and proof methodology. a two-step commitment algorithm which assures transaction update atomicity in a distributed data base is modelled using colored petri nets. the modeling helps in determining the numerous crash possibilities and in specifying recovery procedures and associated protocols. the use of unalterable logs is required and modelled accordingly. a methodology for proof correctness based on linear invariants is presented.
archjava: connecting software architecture to implementation. software architecture describes the structure of a system, enabling more effective design, program understanding, and formal analysis. however, existing approaches decouple implementation code from architecture, allowing inconsistencies, causing confusion, violating architectural properties, and inhibiting software evolution. archjava is an extension to java that seamlessly unifies software architecture with implementation, ensuring that the implementation conforms to architectural constraints. a case study applying archjava to a circuit-design application suggests that archjava can express architectural structure effectively within an implementation, and that it can aid in program understanding and software evolution.
using a web-based project process throughout the software engineering curriculum. in order to facilitate the study and use of software process, which is essential to the education of future software professionals, a standard and tailorable project process has been developed over the last five years at texas tech university for use in both undergraduate and graduate curricula, with a total 12 courses involved. the process is entirely web-based, and includes a complete set of html document templates in order to facilitate the creation of project artifacts which are posted to the course web page. this method enhances communication between team members, including distance education students, and between the project team and client. the project process has received positive feedback from all stakeholders involved.this paper discusses the benefits of the web-based project process, its relation to curriculum models, and plans for a more formal assessment of the process. the portability of process to other institutions is also discussed, with an example provided.
visual timed event scenarios. formal description of real-time requirements is a difficult and error prone task. conceptual and tool support for this activity plays a central role in the agenda of technologytransference from the formal verification engineeringcommunity to the real time systems development practice.in this article we present v ts, a visual language to define complex event-based requirements such as freshness, bounded response, event correlation, etc. the underlyingformalism is based on partial orders and supports real-timeconstraints. the problem of checking whether a timed automatonmodel of a system satisfies these sort of scenariosis shown to be decidable. moreover, we have also developeda tool that translates visually specified scenarios into observertimed automata. the resulting automata can be composedwith a model under analysis in order to check satisfactionof the stated scenarios. we show the benefits of applyingthese ideas to some case studies.
a meta-model for software development resource expenditures. one of the basic goals of software engineering is the establishment of useful models and equations to predict the cost of any given programming project. many models have been proposed over the last several years, but, because of differences in the data collected, types of projects and environmental factors among software development sites, these models are not transportable and are only valid within the organization where they were developed. this result seems reasonable when one considers that a model developed at a certain environment will only be able to capture the impact of the factors which have a variable effect within that environment. those factors which are constant at that environment, and therefore do not cause variations in the productivity among projects produced there, may have different or variable effects at another environment. this paper presents a model-generation process which permits the development of a resource estimation model for any particular organization. the model is based on data collected by that organization which captures its particular environmental factors and the differences among its particular projects. the process provides the capability of producing a model tailored to the organization which can be expected to be more effective than any model originally developed for another environment. it is demonstrated here using data collected from the software engineering laboratory at the nasa/goddard space flight center.
the making of orbix and the iportal suite. iona released the first full implementation of the corba standard in august 1992, and our first product, orbix, has become the most successful object request broker, capturing almost 70-percent of this market. it has spawned many follow-on products from iona and from partner companies. this development followed nearly ten years of research in the area of distributed object systems within trinity college dublin, centered on language support for developers of distributed systems.this paper captures some of the lessons we ve learned in the transition from academia to business. we ve had to learn many software engineering skills. we ve had to find the right mix between engineering, marketing and sales expertise. we ve had to learn how to release new products while staying committed to current ones. and most recently, we ve had to learn how to become an internet-company in order to deliver the iportal suite. for ionaians, it has been a fascinating journey.
formalizing architectural connection. as software systems become more complex the overall system structure - or software architecture - becomes a central design problem. an important step towards an engineering discipline of software is a formal basis for describing and analyzing these designs. we present a theory for one aspect of architectural description, the interactions between components. the key idea is to define architectural connectors as explicit semantic entities. these are specified as a collection of protocols that characterize each of the participant roles in an interaction and how these roles interact. we illustrate how this scheme can be used to define a variety of common architectural connectors. we provide a formal semantics and show how this lends to a sound deductive system in which architectural compatibility can be checked in a way analogous to type checking in programming languages
visualizing software systems. there are many graphical techniques for visualizing software. unfortunately, the current techniques do not scale to display large software systems and are largely unused. we present a method for visualizing statistics associated with code that is divided hierarchically into subsystems, directories, and files. using this technique, we can display the relative sizes of the components in the system, which components are stable and which are changing, where the new functionality is being added, and identify error-prone code with many bug fixes. using animation, we can display the historical evolution of the code
an investigation on the use of machine learned models for estimating correction costs. we present the results of an empirical study in which we have investigated machine learning (ml) algorithms with regard to their capabilities to accurately assess the correctability of faulty software components. three different families of algorithms have been analyzed. we have used (1) fault data collected on corrective maintenance activities for the generalized support software reuse asset library located at the flight dynamics division of nasa's gsfc and (2) product measures extracted directly from the faulty components of this library
problems and programmers: an educational software engineering card game. problems and programmers is an educational card game that we have developed to help teach software engineering. it is based on the observation that students, in a typical software engineering course, gain little practical experience in issues regarding the software process. the underlying problem is time: any course faces the practical constraint of only being able to involve students in at most a few small software development projects. problems and programmers overcomes this limitation by providing a simulation of the software process. in playing the game, students become aware of not only general lessons, such as the fact that they must continuously make tradeoffs among multiple potential next steps, but also specific issues such as the fact that inspections improve the quality of code but delay its delivery time. we describe game play of problems and programmers, discuss its underlying design, and report on the results of a small experiment in which twenty-eight students played the game.
edmas: a locally distributed mail system. the eden project is a five-year effort to design, build and test operating system structures for local area networks. a specific goal is to allow users to obtain the advantages of both physical distribution and logical integration. since eden is physically distributed, its users can take advantage of personal workstations. since eden is logically integrated, system resources can be named and accessed in a location independent way. edmas, the eden mail system, was designed to be an early test of eden's usefulness. this paper describes the design and implementation of edmas, and presents several of the lessons we have learned about constructing location independent services and about the design of mail systems.
evaluating the tradeoffs of mobile code design paradigms in network management applications. the question of whether technologies supporting mobile code are bringing significant benefits to the design and implementation of distributed applications is still an open one. even more difficult is to identify precisely under which conditions a design exploiting mobile code is preferable over a traditional one. in this work, we present an in-depth evaluation of several mobile code design paradigms against the traditional client-server architecture, within the application domain of network management. the evaluation is centered around a quantitative model, which is used to determine precisely the conditions for the selection of a design paradigm minimizing the network traffic related to management
an extensible file system for hydra. an extensible file system has been designed and implemented for hydra, an advanced capability-based operating system. this system demonstrates three notable contributions to subsystem design: - it provides a protected and efficient implementation via user-level code of functions ordinarily implemented as part of a conventional system's monolithic privileged section, - it provides practical solutions to two protection problems, the modification problem and the confinement problem, for users of the file system, and - it provides separation of mechanisms for data representation from mechanisms for protection and synchronization, thus allowing an extensible family of subfile systems to evolve. this paper treats the design and implementation of the hydra file system and reflects on its implications for subsystem design and implementation.
ppt: a cots integration case study. t. rowe price investment technologies built the product and project tracking system (ppt) to reduce the human resources needed to track and forecast information technology projects. instead of developing or purchasing a new system, the need was met by integrating commercial-off-the-shelf (cots) products already used and licensed by the company. the conclusion can be made that this approach reduces development costs while providing more flexibility than a single vendor solution. this paper described the process used and issues encountered in building a system from software products generally intended for stand-alone applications. it discusses the rationale behind the system, the choice of products, the software engineering process used, the handling of changes, and modifications made in business practice. a discussion will be made of the initial return on investment and ongoing support requirements.
research towards a technology to support the specification of data processing system performance requirements. this paper summarizes the results of an initial investigation of a language and underlying technology for the design of data processing system performance requirements. the initial research results indicate that a technology based on petri nets, formal logic, and simulation can be used to describe and analyze some important aspects of data processing performance requirements. these initial language and technology concepts were successfully applied to fully describe a benchmark problem. future research will focus on the implementation and evaluation of automated verification and analysis procedures based on the technology.
a principle for resilient sharing of distributed resources. a technique is described which permits distributed resources to be shared (services to be offered) in a resilient manner. the essence of the technique is to a priori declare one of the server hosts primary and the others backups. any of the servers can perform the primary duties. thus the role of primary can migrate around the set of servers. the concept of n-host resiliency is introduced and the error detection and recovery schemes for two-host resiliency are presented. the single primary, multiple backup technique for resource sharing is shown to have minimal delay. in the general case, this is superior to multiple primary techniques.
inference of message sequence charts. software designers draw message sequence charts for early modeling of the individual behaviors they expect from the concurrent system under design. can they be sure that precisely the behaviors they have described are realizable by some implementation of the components of the concurrent system? if so, can we automatically synthesize concurrent state machines realizing the given mscs? if, on the other hand, other unspecified and possibly unwanted scenarios are "implied" by their mscs, can the software designer be automatically warned and provided the implied mscs? in this paper, we provide a framework in which all these questions are answered positively. we first describe the formal framework within which one can derive implied mscs and then provide polynomial-time algorithms for implication, realizability, and synthesis.
towards an effective software engineering course project. software engineering instructors face many challenges. among these challenges is the course project. instructors are required to train their students on the professional skills to be ready for the real world business, which requires the students to work on real projects. however, because of the low quality of the students' work, not all of the professional organizations are cooperating to offer a chance for the software engineering students to work on a real project. therefore, most of the software engineering courses' projects are in-class project, in which the instructors represent the clients. in this paper, i proposed a solution to this problem based on my experience in involving my software engineering students in real world projects.
bridging the requirements/design gap in dynamic systems with use case maps (ucms). two important aspects of future software engineering techniques will be the ability to seamlessly move from analysis models to design models and the ability to model dynamic systems where scenarios and structures may change at run-time. use case maps (ucms) are used as a visual notation for describing causal relationships between responsibilities of one or more use cases. ucms are a scenario-based software engineering technique most useful at the early stages of software development. the notation is applicable to use case capturing and elicitation, use case validation, as well as high-level architectural design and test case generation. ucms provide a behavioural framework for evaluating and making architectural decisions at a high level of design. architectural decisions may be based on performance analysis of ucms. ucms bridge the gap between requirements and design by combining behaviour and structure in one view and by flexibly allocating scenario responsibilities to architectural components. they also provide dynamic (run-time) refinement capability for variations of scenarios and structure and they allow incremental development and integration of complex scenarios. therefore, ucms address the issues mentioned above.