waashk/acm huggingface dataset:
the ergo attribute system  the ergo attribute system was designed to satisfy the requirements for attributes in a language-generic program derivation environment. it consists of three components: (1) an abstract data type of attributes that guarantees attribute consistency, (2) a common lisp implementation which combines demand- driven and incremental attribute evaluation in a novel way while allowing for attribute persistence over many generations of a program, and (3) an attribute-grammar compiler producing code based on this abstract data type from a high-level specification. our experience with three major applications (one being the attribute-grammar compiler itself) confirms that the overhead in storing and accessing attributes incurred by our implementation scheme is more than offset by the gains from the demand-driven, incremental, and persistent nature of attribution.  robert l. nord frank pfenning
a relations-based approach for simplifying metrices extraction the field of software metrics is constantly changing and metrics extraction tools have to be updated frequently to handle these changes. this paper details the use of an intermediate relation set to decouple code parsing from metrics analysis. parsers simply generate a set of intuitive relations, which a separate analyzer uses as input to compute arbitrary metrics. then, new metrics simply have to be specified in terms of these relations. a c++ metrics extractor tool for oo design metrics was built as a proof of concept. giancarlo succi eric liu
metrics in software quality assurance  the nature of "software quality" and some software metrics are defined and their relationship to traditional software indicators such as "maintainability" and "reliability" are suggested. recent work in the field is summarized and an outlook for software metrics in quality assurance is provided. the material was originally presented as a tutorial at the "acm sigmetrics workshop/symposium on measurement and evaluation of software quality" on march 25, 1981.  j. e. gaffney
a tool for designing java programs with uml this project intends to develop a simple uml (unified modeling language) tool in java to be used by students learning object-oriented design and java programming. each student will be able to design a java program by filling in forms (use cases, crc cards) and making diagrams (use case diagrams, class diagrams and sequence diagrams) in a number of views. when the student enters information for any one of the views the tool will update the equivalent information for the other views. the tool will generate java skeleton code from information supplied by the student. anna armentrout
a constructive alternative to axiomatic data type definitions  many computer scientists advocate using axiomatic methods (such as algebraic specification) to specify a program data domain---the universe of abstract data objects and operations manipulated by a program. unfortunately, correct axiomatizations are difficult to write and to understand. furthermore, their non-constructive nature precludes automatic implementation by a language processor.  in this paper, we present a more disciplined, purely constructive alternative to axiomatic data domain specification. instead of axiomatizing the program data domain, the programmer explicitly constructs it by using four type construction mechanisms: constructor generation, union generation, subset generation, and quotient generation. these mechanisms are rich enough to define all of the abstract data objects that programmers commonly use: integers, sequences, trees, sets, arrays, functions, etc. in contrast to axiomatic definitions, constructive definitions are easy to write and to understand. an unexpected advantage of the constructive approach is a limited capacity to support non-deterministic operations. as an illustration, we define a non-deterministic "choose" operation on sets.  robert cartwright
high-level language debugging for concurrent programs  an integrated system design for debugging distributed programs written in concurrent high- level languages is described. a variety of user-interface, monitoring, and analysis tools integrated around a uniform process model are provided. because the tools are language-based, the user does not have to deal with low-level implementation details of distribution and concurrency, and instead can focus on the logic of the program in terms of language-level objects and constructs. the tools provide facilities for experimentation with process scheduling, environment simulation, and nondeterministic selections. presentation and analysis of the program's behavior are supported by history replay, state queries, and assertion checking. assertions are formulated in linear time temporal logic, which is a logic particularly well suited to specify the behavior of distributed programs.  the tools are separated into two sets. the language-specific tools are those that directly interact with programs for monitoring of and on-line experimenting with distributed programs. the language-independent tools are those that support off-line presentation and analysis of the monitored information. this separation makes the system applicable to a wide range of programming languages. in addition, the separation of interactive experimentation from off-line analysis provides for efficient exploitation of both user time and machine resources. the implementation of a debugging facility for occam is described.  german s. goldszmidt shaula yemini
why smalltalk?  smalltalk is a single paradigm language with very simple semantics and syntax for specifying elements of a system and for describing system dynamics [1]. when the language is used to describe an application system, the developer extends smalltalk, creating a domain- specific language by adding a new vocabulary of language elements while maintaining the same semantics and syntax. using most smalltalk systems, it is easy to invent one's own development environment through inclusion of new system parts in the library and extension of the development tools. moreover, it is possible to make changes to the environment, and to applications written using the environment, while the system is executing. these system characteristics create a flexible and enjoyable software development experience.  adele goldberg
task termination and ada 95 ada 83 removed from the programmer the burden of coding potentially complex termination conditions between clients and servers by introducing an 'or terminate' option to the select statement. with the introduction of indirect communication (emphasised by the provision of protected objects in ada 95), it is no longer straightforward to obtain program termination. this paper illustrates the problem and suggests that adding a terminate alternative to an entry call might solve the problem. the advantages and disadvantages of the approach are discussed. a. j. wellings a. burns o. pazy
paging on an object-oriented personal computer  a high-performance personal computing environment must avoid perceptible pauses resulting from many page faults within a short period of time. our performance goals for a paged virtual memory system for the smalltalk-80tm@@@@; programming environment are both to decrease the average page fault rate and to minimize the pauses caused by clusters of page faults. we have applied program restructuring techniques to the smalltalk-80 object memory in order to improve the locality of reference. the analysis in this paper considers the clustering of page faults over time and distinguishes between steady-state behavior and phase transitions. we compare the effectiveness of different restructuring strategies in reducing the amount of main memory needed to obtain desired levels of performance.  ricki blau
an integrated approach to software reuse practice  since 1993, sodalia's software engineers have been studying a reuse program whose goal is making software reuse a significant and systematic part of the software process. the sodalia's corporate reuse program is intended to develop a software reuse process that incorporates reuse-specific activities along the object-oriented software development process, and a reuse library to support the classification and management of reusable components.  this paper focuses on the on-going experience of sodalia in the gradual introduction of reuse practice in the organization, illustrates the evolutionary stages, and the reached results.  e. mambella r. ferrari f. d. carli a. l. surdo
infinite loops and how to create them  infinite loops are the worst enemy of any programmer in any language. they waste potentially huge amounts of time, system resources and/or money, and can destroy the credibility of the programmer amongst colleagues or customers.  in apl, infinite loops can potentially occur wherever a loop is present. however, they can also occur wherever any branching statement is used, and can even occur where no branching instructions have been used. in order to avoid infinite loops, the programmer is best equipped if he/she is aware of all of the possible ways in which they may be created.  an apl function is also presented which will give programmers new to the language a means whereby most infinite loops can be avoided in their training phase.  john r. searle
establishing ada repositories for reuse  ideally, a software reuse repository is a robust, dynamic interchange among software designers. this constantly growing and improving resource assists with---and influences---the creation of quality, cost-efficient software systems.  setting this process in motion and sustaining its momentum calls for many of the approaches used in system design and development. its stable yet flexible structure anticipates the technical requirements of present and future users. but the successful repository reflects a broader perspective, a long-term commitment, and attention to a number of other technical and nontechnical issues. it must maintain components beyond the development cycle of supported projects. it must have a capability for continuity. and most important, it must be a value-added, self-sustaining resource.  saic's experience with three significant ada reuse repositories has given us insights into a number of relevant issues and challenges, and has shown us the intricate relationships that link the technical, economic, human and other contributing factors affecting repository development and operation. these three repositories---stars, aflc and saic corporate---support software reuse and a number of additional specialized requirements. the software technology for adaptable, reliable systems (stars) repository serves as a testbed for repository and reuse technology. additional requirements include a means for sharing program-related information such as meeting minutes, presentations, contract data requirements lists (cdrl) items and peer reviews. the air force logistics command (aflc) ada software repository has been established to provide a means of sharing domain-specific information among software development and maintenance personnel at the air logistics commands. with the wide variety of domain-specific software developed at saic, the company has decided to institute a reuse program to enhance the quality of this domain software and to encourage cross-domain reuse.  common objectives for these projects include long- term continuity and self- sustaining capabilities. our experience to date has shown that these objectives impact four principal areas of the repository system:  content acquisition/update  technical information services  operational su pport  facilities  b. kitaoka
lazy array data-flow dependence analysis  automatic parallelization of real fortran programs does not live up to users expectations yet, and dependence analysis algorithms which either produce too many false dependences or are too slow to contribute significantly to this. in this paper we introduce dataflow dependence analysis algorithm which exactly computes value- based dependence relations for program fragments in which all subscripts, loop bound and if conditions are affine. our algorithm also computes good affine approximations of dependence relations for non-affine program fragments. actually, we do not know about any other algorithm which can compute better approximations.  and our algorithm is efficient too, because it is lazy. when searching for write statements that supply values used by a given read statement, it starts with statements which are lexicographically close to the read statement in iteration space. then if some of the read statement instances are not "satisfied" with these close writes, the algorithm broadens its search scope by looking into more distant writes. the search scope keeps broadening until all read instances are satisfied or no write candidates are left.  we timed our algorithm on several benchmark programs and the timing results suggest that our algorithm is fast enough to be used in commercial compilers ---it usually takes 5 to 15 percent of f77 -02 compilation time to analyze a program. most programs in the 100-line range take less than 1 second to analyze on a sun sparcstation ipx.  vadim maslov
issues in ada's future sponsored by acm/adatc (panel discussion)  the ada programming language has gone public. the department of defense originally sponsored the effort in order to develop a high level language which could be used in real time computer systems. such systems are written in assembly language or in obscure languages such as cms (navy), jovial (air force), and tacpol (army). each of the high level languages in current use by the services has deficiencies which require the use of assembly language in almost all applications. in fact, most of the real time applications which are written supposedly in a high level language are written actually in assembly language because the compilers accept assembly language statements. this sad state of affairs has resulted because none of the current language can handle all of the requirements of real time applications. for example, there exist at least four dialects of jovial (j2, j3, j3b, and j73) none of which have a basic input or output capability.  some of the problems which result from the use of assembly language and obscure languages are logistical rather than technical: a small number of people know these languages; there is a dearth of training material and courses; there is no portability of programs or people between systems which use these languages; the programming environments for each of the languages is poor; the languages are not available on many computer systems.  sabina h. saib
report on a workshop on software change and evolution this paper provides a brief overview and report on the main out-comes of the software change and evolution (sce99) workshop held in los angeles on may 17, 1999, as part of the international conference on software engineering 1999.the purpose of the workshop was to gather the most active of researchers and practitioners in the field of software evolution and change. the overall conclusion of the workshop was that this is a topic of enormous importance to industry, and there is a growing community of both practitioners and researchers who are working in the field. it would therefore make sense to arrange further workshops to support this expanding community. v. t. rajlich s. rank n. wilde k. h. bennett
objects to the rescue! or httpd: the next generation operating system this position paper suggests that object-oriented operating systems may provide the means to meet the ever-growing demands of applications. as an example of a successful ooos, we cite the http daemon. to support the contention that _httpd_ is in fact an operating system, we observe that it implements uniform naming, persistent objects and an invocation meta-protocol, specifies and implements some useful objects, and provides a framework for extensibility.we also believe that the modularity that is characteristic of oo systems should provide a performance benefit rather than a penalty. our ongoing work in the synthetix project at ogi is exploring the possibilities for advanced optimizations in such systems. andrew p. black jonathan walpole
multi-dispatch in the java virtual machine (poster session): design and implementation  mainstream object- oriented languages, such as c++ and java, provide only a restricted form of polymorphic methods, namely single-receiver dispatch. in common programming situations, programmers must work-around this limitation. we detail how to extend the java virtual machine to support multiple-dispatch and examine the complications that java imposes on multiple-dispatch in practice. our technique avoids changes to the java programming language itself, maintains source-code and library compatibility, and isolates the performance penalty and semantic changes of multiple-dispatch to the program sections which use it. we have micro-benchmark and application-level performance results for a dynamic _most specific applicable_ (msa) dispatcher, two table-based dispatchers (_multiple row displacement_ (mrd) and _single receiver projections_ (srp)), and a tuned srp dispatcher. our general-purpose technique provides smaller dispatch latency than equivalent programmer-written double-dispatch code.  christopher dutchyn paul lu duane szafron steve bromling wade holst
designing concurrent, distributed, and real-time applications with uml  object-oriented concepts are crucial in software design because they address fundamental issues of adaptation and evolution. with the proliferation of object-oriented notations and methods, the unified modeling language (uml) has emerged to provide a standardized notation for describing object-oriented models. however, for the uml notation to be effectively applied, it needs to be used with an object-oriented analysis and design method. this tutorial describes the comet method for designing real-time and distributed applications, which integrates object-oriented and concurrency concepts and uses the uml notation.  hassan gomaa
generating a requirements specifications knowledge-base  the requirements specifications phase of the software life cycle plays a vital role within the overall development process. existing methodologies provide a formalized specification document for use by the design phase. however, such methods generally rely on heuristic or ad-hoc methods for their initial conversion from the english requirements document to the formalized system specification.  a methodology is under development by which the english requirements document is converted into a reliable set of knowledge for use within the specification process. such a method would be utilized to help improve the overall quality and reliability of the resulting specification document. this method provides a three-phase conversion from the initial english document into a knowledge- based tool for use by the system specification group.  the initial phase in the methodology uses as input a standard english requirements document and produces a structured parse of this text. this step utilizes the concept of augmented transition networks [1] for the conversion. the grammar used in constructing the atn is based on chomsky's transformational english grammar [2]. inherent ambiguities within the document are resolved interactively with the user/analyst.  the second phase converts this structured parse into a set of prolog-based facts and rules that encapsulate the knowledge within the initial document. these facts can be divided into three major classifications: hierarchies, properties and events. hierarchy facts detail the relationships that exist between the entities themselves, as described within the requirements document. property facts specify the specific characteristics (physical and logical) of an individual entity. finally, event facts provide information regarding the actual actions that take place within the proposed system. the specific action being performed, the entity invoking this action, and all other entities in this event are detailed.  in addition to these facts, other relevant information is stored within the knowledge base. rules exist for the definition of the specific actions and entities referenced within the requirements specification document. the quantification of all abstract modifiers used within the document is performed interactively with the user/analyst. in addition, the method links the origin of all knowledge-base information back to the original requirements specification document itself. a final set of rules permits restrictions to be placed on specific entity characteristics (properties) or upon events themselves.  the final phase checks the accumulated knowledge for reliability, understandability and traceability [3]. reliability checking includes examining the aspects of correctness, completeness, consistency and necessity. testability relates to the overall quantification, structure, conciseness and self-description within the document. traceable information augments the user's ability to track the correspondence of the entities and actions within the generated knowledge base back to the initial requirements document.  d. w. cordes d. l. carver
abstraction, data types, and models for software  in the area of software development and maintenance, a major issue is managing the complexity of the systems. programming methodologies and languages to support them have grown in response to new ideas about how to cope with this complexity. a dominant theme in the growth of methodologies and languages is the development of tools dealing with abstractions. an abstraction is a simplified description, or specification, of a system that emphasizes some of its details or properties while suppressing others. a good abstraction is one in which information that is significant to the reader (i.e., the user) is emphasized while details that are immaterial, at least for the moment, are suppressed.  what we call "abstraction" in programming systems corresponds closely to what is called "modelling" in many other fields. it shares many of the same problems deciding which characteristics of the system are important, what variability (i.e., parameters) should be included, which descriptive formalism to use, how the model can be validated, and so on  mary shaw
a single-pass syntax-directed front end for ada  this paper describes the front-end processor of an ada compiler that is under development at florida state university. the compiler is coded in pascal, to execute on a cdc cyber system, and is presently targeted to the z8000 microprocessor architecture. owing at least in part to the peculiar origins and changing goals of this project, the front end processor is rather unlike those of the other ada compilers of which we know. perhaps its most distinctive feature is that it operates in one pass.  t. p. baker
an object-oriented file system - an example of using the class hierarchy framework concept this paper presents the design of an object-oriented file system which was developed as a part of the "objix object-oriented operating system" project. the file system is a self-contained program system which is decomposed using a standard object-oriented framework concept. a novel approach to object-oriented frameworks, the class hierarchy framework concept recapitulated in this paper, is employed in structuring components of the file system. further, this paper illustrates on an example how the file system pursues a typical system call. tomas smolik