waashk/acm huggingface dataset:
problem-solution mapping in object-oriented design  six expert smalltalk programmers and three expert procedural programmers were observed as they worked on a gourmet shopping design problem; they were asked to think aloud about what was going through their minds as they worked. these verbal protocols were recorded and examined for ways in which the programmers' understanding of the problem domain affected the design process; most of our examples are from the three smalltalk programmers who focussed most on the mapping from problem to solution. we characterize the problem entities that did appear as solution objects, the active nature of the mapping process, and ways in which the resultant objects went beyond their problem analogs.  m. b. rosson e. gold
"tolerating inconsistency" revisited  we're surrounded by inconsistency: in our requirements, in the data that our software processes, and in those software systems themselves, yet our formal systems can't handle such inconsistency. most of them lose the ability to form any valid conclusions or analyses in the presence of even a single inconsistency.  this forces our programs to operate in terms of an idealized model rather than the real world with the attendant requirement to either maintain a mapping between the two or force human operators to resolve the inconsistencies before the data is processed by the idealized system.  my "tolerating inconsistency paper introduced a simple way to scope formal constraint systems so that they applied only to the consistent data. data inconsistent with these rules could then be represented and processed by giving them special marks to place them outside the rules' scope.  my talk will review the influence this idea had on the field and my subsequent work.  robert balzer
typographic style is more than cosmetic  there is disagreement about the role and importance of typographicstyle (source code formatting and commenting) in program comprehension.results from experiments and opinions in programming style books aremixed. this article presents principles of typographic style consistentand compatible with the results of program comprehension studies. fourexperiments demonstrate that the typographic style principles embodiedin the book format significantly aid program comprehension and reducemaintenance effort.  \\---authors' abstract paul w. oman curtis r. cook
a multi-processing implementation-oriented formal definition of ada in semanol  a formal definition of the syntax and semantics of preliminary ada has been designed and partially implemented as a metaprogram in the semanol system. the paper describes the design in detail and also presents excerpts of the actual semanol metaprogram. special attention is paid to the following aspects, lacking in the formal denotational definition of ada: (1) formal definition of the connection between the concrete and abstract syntax of ada, a necessary element of a formal definition if it is to be executable; (2) formal definition of the semantics of concurrency in ada tasking; (3) formal definition of the semantics of exceptions and interrupts. the complete semanol metaprogram will be an executable formal definition. in effect, it defines a multi-processing operating system which accepts an ada program, as a set of compilation units, together with data, and causes the program to be executed in a concurrent mode in accordance with the semantics of tasks prescribed in the ada reference manual and rationale.  f. c. belz e. k. blum d. heimbigner
extending halstead's software science for a more precise measure of apl  software engineering is a growing part of computer science. software engineering attempts to put measurements and metrics into the area of software programming. one of these metrics, halstead's software science [1], measures a program's difficulty, a language level, and in turn, a programmer's productivity. software science uses an extensive measure as opposed to the intensive measure of most other software engineering techniques. this is accomplished by counting functions and operands, and applying several formulae modified from thermodynamics. even though software science attempts to place an objective measurement on these parameters, it is not meant to be a definitive decision tool, but rather a general guideline. this paper will explore the possible extension of halstead's theory to include operators, as defined in apl, in the counting methodology and software science formulae.  ross a. mauri a. harry williams
principles for writing reusable libraries  over the past 10 years, the software engineering research department in at&amp;t; has been engaging in a research program to build a collection of highly portable advanced software tools known as ast, advanced software technology. a recent monograph, "practical reusable unix software" (john wiley & sons, inc., 1995), summarizes the philosophy and components of this research program. a major component of this program is a collection of portable, and reusable libraries servicing a wide range of functions, from a porting base to all known unix platforms, to efficient buffered i/o, memory allocation, data compression, and expression evaluation. the libraries currently stand at about 150,000 non-commented lines of c code. they are developed and maintained independently by different researchers. yet they work together seamlessly--- largely because of a collection of library design principles and conventions developed to help maintaining interface consistency and reducing needless or overlapped work.  glenn s. fowler david g. korn kiem-phong vo
integrating a software engineering approach into an ada closed laboratory a manual for a closed laboratory incorporating software engineering concepts was developed and implemented for ada'95 during the 1998-1999 academic year. the software engineering concepts were applied during the development and implementation. the purpose was to teach student programmers (and prospective software engineers) disciplined methods for developing software. the findings were: 1. the closed laboratory provided an ideal environment for students to explore, learn and implement software development methods as well as learn the ada language. 2. the closed laboratory was a major contributor for students to understand the course contents and built a bridge between the class lectures and open lab projects. 3. the closed laboratory helped students to accomplish their open lab projects in a more efficient and professional way by following software development methods. a survey conducted at the end of the semester indicated the success of implementation of software development methods in the ada closed laboratory. the responses showed that students enjoyed the closed laboratory and considered it an exciting and interesting learning experience. ming wang
safety critical systems based on formal models the ravenscar profile for high integrity systems using ada 95 is well defined in all real-time aspects. the complexity of the run-time system has been reduced to allow full utilization of formal methods for applications using the ravenscar profile. in the mana project a tool set is being developed including a formal model of a ravenscar compliant run-time system, a gnat compatible run-time system, and an asis based tool to allow for the verification of a system including both cots and code that is reused. lars asplund kristina lundqvist
the most important technical library in the world intel provides several libraries known as the performance library suite to address several computational areas: signal processing, image processing, speech and character recognition and linear algebra. this latter library is known as the math kernel library, or mkl.in this paper we discuss the methods we use to achieve high performance on the current version. these methods revolve primarily around the management of memory and minimization of branch costs. memory management involves compensating for the mismatch in main memory performance compared to the processor consumption rate, latency hiding, cache management and tlb management.we also discuss the smp capabilities and the performance thereof.we discuss the direction the library will be taking including additions that will be made to the offerings: multithreaded lapack, cblas interface, and a powerful graphical dll builder to create custom libraries no larger than the end user requires. finally we will point out that using libraries such as mkl permits the user to profit from the architectural advances in new processors even if the tools, especially compilers, may not be able to fully exploit the features. there will be versions of mkl which exploit features of the recently announced katmai processor, and the library will be fully developed for the merced processor when it is introduced. bruce greer
mach and matchmaker: kernel and language support for object-oriented distributed systems  mach, a multiprocessor operating system kernel providing capability-based interprocess communication, and matchmaker, a language for specifying and automating the generation of multi-lingual interprocess communication interfaces, are presented. their usage together providing a heterogeneous, distributed, object-oriented programming environment is described. performance and usage statistics are presented. comparisons are made between the mach/matchmaker environment and other related systems. possible future directions are examined.  michael b. jones richard f. rashid
signature matching: a tool for using software libraries  signature matching is a method for organizing, navigating through, and retrieving from software libraries. we consider two kinds of software library components---functions and modules--- and hence two kinds of matching--- function matching and module matching. the signature of a function is simply its type; the signature of a module is a multiset of user-defined types and a multiset of function signatures. for both functions and modules, we consider not just exact match but also various flavors of relaxed match. we describe various applications of signature matching as a tool for using software libraries, inspired by the use of our implementation of a function signature matcher written in standard ml.  amy moormann zaremski jeannette m. wing
metaclass compatibility  metaclasses provide control of object description, method compilation and more generally class behaviour. consequently, they have been widely used in languages such as smalltalk-80 or more recently clos by both users and implementers. due to their powerful control of instances, careless inheritance of classes with different metaclasses can lead to unsound or inefficient implementations of instance methods. using examples, we will pin-point these problems. then we will introduce compatibility rules which need to be fulfilled by metaclasses of inherited classes in order to allow reasonable instance method description.  n. graube
macros as multi-stage computations: type-safe, generative, binding macros in macroml with few exceptions, macros have traditionally been viewed as operations on syntax trees or even on plain strings. this view makes macros seem ad hoc, and is at odds with two desirable features of contemporary typed functional languages: static typing and static scoping. at a deeper level, there is a need for a simple, usable semantics for macros. this paper argues that these problems can be addressed by formally viewing macros as multi-stage computations. this view eliminates the need for freshness conditions and tests on variable names, and provides a compositional interpretation that can serve as a basis for designing a sound type system for languages supporting macros, or even for compilation. to illustrate our approach, we develop and present macroml, an extension of ml that supports inlining, recursive macros, and the definition of new binding constructs. the latter is subtle, and is the most novel addition in a statically typed setting. the semantics of a core subset of macroml is given by an interpretation into metaml, a statically-typed multi-stage programming language. it is then easy to show that macroml is stage- and type-safe: macro expansion does not depend on runtime evaluation, and both stages do not "go wrong. steven e. ganz amr sabry walid taha
sw 2 - an object-based programming environment  programming systems traditionally deal with only a few different types of data objects. operating- system command languages, for example, are concerned with files and programs. typical programming languages deal with computer-related objects such as integers, strings, arrays, and records. this is in sharp contrast to the variety of real-world objects that people reason about. smallworld is a programming environment in which the real world is represented by objects that have properties. a property represents a fact about the corresponding real-world entity. thus smallworld actions (programs), which operate on objects specified in this simple but general way, are "smart": they consider all of the relevant facts concerning (that is, all of the properties of) the objects they manipulate.  smallworld was strongly influenced by the design of smalltalk, especially in the organization of objects into classes and superclasses. the two languages differ (1) in their treatment of the difference between classes and objects that are not classes and (2) in their definition of methods that act on classes. smallworld minimizes the differences between classes and non-class objects, resulting in a simpler and more consistent system. where smalltalk is a programming language using a pure object-oriented paradigm and dependent on a powerful graphical interface, smallworld is a shell language that runs on conventional terminals and allows multiple program paradigms where appropriate.  mark r. laff brent hailpern
generating parallel code from object oriented mathematical models  for a long time efficient use of parallel computers has been hindered by dependencies introduced in software through low-level implementation practice. in this paper we present a programming environment and language called object- math (object oriented mathematical language for scientific computing), which aims at eliminating this problem by allowing the user to represent mathematical equation-based models directly in the system. the system performs analysis of mathematical models to extract parallelism and automatically generates parallel code for numerical solution.  in the context of industrial applications in mechanical analysis, we have so far primarily explored generation of parallel code for solving systems of ordinary differential equations (odes), in addition to preliminary work on generating code for solving partial differential equations. two approaches to extracting parallelism have been implemented and evaluated: extracting parallelism at the equation system level and at the single equation level, respectively. we found that for several applications the corresponding systems of equations do not partition well into subsystems. this means that the equation system level approach is of restricted general applicability. thus, we focused on the equation-level approach which yielded significant parallelism for ode systems solution. for the bearing simulation applications we present here, the achieved speedup is however critically dependent on low communication latency of the parallel computer.  niclas andersson peter fritzson
secured systems and ada: a trusted system software architecture  in this paper, we will present an architecture for developing a system reliant upon trusted ada software, and some of the lessons learned in our having done such a development. some background on trusted software and the trusted information systems within which such ada software operates is provided, as well as some theoretical and practical aspects of the use of ada in developing these systems. the notion of a trusted computing base (tcb) is presented and defined. a generalized trusted software development approach will be adduced and some aspects of developing cmw tcb components are offered.  mark aldrich
tenuring policies for generation-based storage reclamation  one of the most promising automatic storage reclamation techniques, generation-based storage reclamation, suffers poor performance if many objects live for a fairly long time and then die. we have investigated the severity of this problem by simulating generation scavenging automatic storage reclamation from traces of actual four-hour sessions. there was a wide variation in the sample runs, with garbage-collection overhead ranging from insignificant, during the interactive runs, to severe, during a single non-interactive run. all runs demonstrated that performance could be improved with two techniques: segregating large bitmaps and strings, and mediating tenuring with demographic feedback. these two improvements deserve consideration for any generation- based storage reclamation strategy.  david ungar frank jackson
data (session summary)  this session addressed the object base and typing issues needed in support of the modeling and implementation of the life-cycle process. in this summary the terms process and life-cycle process are used interchangeably. however, i do not believe that was the case during the workshop; sometimes it seemed that the term process was used in an abstract way1, which led, at times, to some conceptual misunderstandings.  jack wileden was the keynote speaker for the session. he started by trying to differentiate between two (2) roles in process modeling:  the actual modeling of the process, i.e., how do we describe the process independent of its implementation.  process enaction and the environment needs in support of the process model descriptions.  he felt most position papers dealt with the second role, even though a few talked about the first. there was not too much discussion with respect to the differences of those roles but performance was mentioned as a key issue for the second role.  wileden proceeded to distinguish an overall "world view" on data issues from specific dimensions of the data support problem (see section 2 for his list of specific dimensions). he listed several possible world views with respect to data in support of life-cycle processes, including: i) typed objects as in programming languages, ii) files (e.g., documents, code, etc), iii) traditional database view. he described his own view as based on the notion of an "object space" (i.e., collections of objects). this more modern view appears to be shared by many of the workshop participants, as reflected in many of the position papers. the group decided not to debate on the definition of the word object, but to consider it related to the concept of abstract data types. (note: i like to think of objects as the units of data which are identifiable and accessible within a software engineering environment (see) and of an object management system (oms) as the see component whose objective is to manage those objects; a precise definition of an object is largely dependent on the type model provided by an oms.)  this session did not try to generate lists of issues or requirements. the objective seemed to be to discuss items which were felt important by the group. there were few agreements. nonetheless, an emerging consensus seemed to be that the current state of the art and state of the practice in database management systems (or object management systems) do not support all the needs of process programming.  this summary will concentrate on some of the key items and/or issues discussed, followed by some observations made during the session.  maria h. penedo
non-intrusive and interactive profiling in parasight  debugging the performance of parallel applications is crucial for fully utilizing the potential of multiprocessor hardware. this paper describes profiling tools in parasight, a programming environment that is geared towards non-intrusive performance analysis and high-level debugging. in parasight, profilers execute as observer programs which run concurrently with the target program and monitor its behavior. this design grew out of our experience in debugging and monitoring the performance of real parallel programs.  parasight is used to implement an interactive profiler based on gprof, a standard unix profiling tool. the new profiler is an interactive tool that is dynamically controlled by the programmer and can run concurrently with the target program. it is also less intrusive than the original. this was achieved in part by off-loading the profile gathering computations to an adjacent processor and in part by allowing selective profiling.  in conjunction with the new profiler, parasight is used to implement high- level custom profiling routines that may be inserted at arbitrary locations in a target program to measure user-defined abstractions. one outcome has been to develop the beginnings of a profiling methodology in which high-level performance problems are detected through a function profiler and detailed performance bottlenecks are analyzed with custom profiling routines.  parasight, the new profiler and their associated tools have been implemented on the encore multimax, a shared- memory multiprocessor running unix. they have been used to profile both parallel and sequential programs.  ziya aral ilya gertner
an introduction to trellis/owl  trellis/owl is an object-based language incorporating a type hierarchy with multiple inheritance and compile- time type checking. the combination of features in the language facilitates the design, implementation, and evolution of large computer programs. this paper provides an brief introduction to the trellis/owl language. it discusses the basic elements of the language, objects, and shows how these are specified and implemented using types, operations, and components. the notion of a type hierarchy is introduced by a discussion of subtyping and inheritance. other elements of the trellis/owl language such as type generators, iterators, and exceptions are briefly presented.  craig schaffert topher cooper bruce bullis mike kilian carrie wilpolt
implementing constraint imperative programming languages: the kaleidoscope'93 virtual machine  constraint imperative programming (cip) languages integrate declarative constraints with imperative state and destructive assignment, yielding a powerful new programming paradigm. however, cip languages are difficult to implement efficiently due to complex interactions between the two donor paradigms. neither the virtual machines for classical object-oriented languages, nor those for existing constraint languages, are suitable for implementing cip languages, as each assumes a purely imperative or a purely declarative computation model. we have developed a new virtual machine for cip languages, the k-machine, an imperative machine with an incremental constraint solver and a constraint-based, rather than value-based, data store. this virtual machine allows user-defined constraints to be defined using constraint constructor definitions which are the cip analog to method definitions. similar to methods, these constructors are able to reference variables indirectly through many levels of pointers. the k-machine maintains relations between objects in the presence of state change to these indirectly referenced objects. the k-machine is capable of supporting a wide variety of cip languages, including our most recent: kaleidoscope'93.  gus lopez bjorn freeman-benson alan borning
smart recompilation and the gnat compiler  the gnat project at new york university is building a high-quality ada 9x compiler, to be distributed free and with sources, following the successful mechanisms established by the free software foundation for the gcc compiler.  this paper describes the design of a smart recompilation system that is currently being implemented on top of the gnat compiler. the foundations upon which smart gnat rests are also the starting point for software engineering tools such as a source browser, a cross referencer and an intelligent ada make.  franco gasperoni patrick bazire