waashk/dblp huggingface dataset:
generating wrappers for command line programs: the cal-aggie wrap-o-matic project. software developers writing new software have strong incentives to make their products compliant to standards such as corba, com, and java beans. standards-compliance facilitates inter-operability, component-based software assembly, and software reuse, thus leading to improved quality and productivity. legacy software, on the other hand, is usually monolithic, and hard to maintain and adapt. many organizations, saddled with entrenched legacy software, are confronted with the need to integrate legacy assets into more modern, distributed, componentized systems that provide critical business services. thus wrapping legacy systems for inter-operability has been an area of considerable interest. wrappers are usually constructed by hand which can be costly and error-prone. in this paper, we specifically target command-line oriented legacy systems and describe a tool framework that automates away some of the drudgery of constructing wrappers for these systems. we describe the cal-aggie wrap-o-matic system (cawom), and illustrate its use to create corba wrappers for a) the jdb debugger, thus supporting distributed debugging using other corba components, and b) the apache web-server, thus allowing remote web-server administration, potentially mediated by corba-compliant security services. while corba has some limitations, in several relatively common settings it can produce better wrappers at lower cost.
dado: enhancing middleware to support crosscutting features in distributed, heterogeneous systems. some "non-" or "extra-functional" features, such as reliability, security, and tracing, defy modularization mechanisms in programming languages. this makes such features hard to design, implement, and maintain. implementing such features within a single platform, using a single language, is hard enough. with distributed, heterogeneous (dh) systems, these features induce complex implementations which cross-cut different languages, oss, and hardware platforms, while still needing to share data and events. worse still, the precise requirements for such features are often locality-dependent and discovered late (e.g., security policies). the dado1 approach helps program cross-cutting features by improving dh middleware. a dado service comprises pairs of adaplets which are explicitly modeled in idl. adaplets may be implemented in any language compatible with the target application, and attached to stubs and skeletons of application objects in a variety of ways. dado supports flexible and type-checked interactions (using generated stubs and skeletons) between adaplets and between objects and adaplets. adaplets can be attached at run-time to an application object. we describe the approach and illustrate its use for several cross-cutting features, including performance monitoring, caching, and security. we also discuss software engineering process, as well as run-time performance implications.
design and implementation of distributed crosscutting features with dado. some "non-" or "extra-functional" features, such as reliability, security, and tracing, defy modularization mechanisms in programming languages. with distributed, heterogeneous (dh) systems, these features induce complex implementations which crosscut different languages, oss, and hardware platforms, while still needing to share data and events. the dado approach helps program crosscuting features by improving dh middleware. a dado service comprises pairs of adaplets which are explicitly modeled in idl. dado supports flexible and type-checked interactions (using generated stubs and skeletons) between adaplets and between objects and adaptlets. adaptlets can be attached at run-time to an application object.
glueqos: middleware to sweeten quality-of-service policy interactions. a holy grail of component-based software engineeringis "write-once, reuse everywhere". however, inmodern distributed, component-based systems supportingemerging application areas such as service-orientede-business (where web services are viewed as components)and peer-to-peer computing, this is difficult. non-functional requirements (related to quality-of-service (qos) issues such as security, reliability,and performance) vary with deployment context, andsometimes even at run-time, complicating the task ofre-using components. in this paper, we present amiddleware-based approach to managing dynamicallychanging qos requirements of components. policiesare used to advertise non-functional capabilities andvary at run-time with operating conditions. we alsoprovide middleware enhancements to match, interpret,and mediate qos requirements of clients and servers atdeployment time and/or runtime.
software improvements in an international company. the schlumberger laboratory for computer science (slcs) was formed in 1989 as a corporate-wide resource to enhance the quality and creativity of software products within schlumberger and to improve the productivity of software development. because of a wide range of needs, it was necessary to decide which techniques slcs's small software improvement team could use most effectively. the authors describe the choices made and the effectiveness of those choices in work with schlumberger's engineering organizations. through the motivation efforts of a small group, productive changes have occurred across the company. improvements were made in many development areas, including project planning and requirements management. the catalysts behind these advances included capability assessments, training, and collaboration
requirements interaction management in an extreme programming environment: a case study. this work reports experience applying the process of requirements interaction management (rim) within the context of developing a commercial, internet-based software application in an industrial venue, employing the extreme programming (xp) methodology. we describe our means of managing the interactions -- by extending the standard xp requirements process while maintaining consistency with the principles of xp itself. we outline our rationale for modifying the xp requirements process, and provide a temporal comparison showing that, for this project, modified process is essential to successful application of rim.
interface control and incremental development in the pic environment. the pic environment is designed to provide support for interface control that facilitates incremental development of a software system. interface control, the description and analysis of relationships among system components, is important from the earliest stages of the software development process right through to the implementation and maintenance stages. incremental development, wherein a software system is produced through a sequence of relatively small steps and progress may be rigorously and thoroughly assessed after each step, must be accommodated by any realistic model of the software development process. this paper focuses on the analysis component of the pic environment and demonstrates how it contributes to precise interface control capabilities while supporting an incremental software development process.
use of software inspection inputs in practice. the effects in the empirical study of different kinds of inputs on the software inspection process can be classified into explicit inputs and implicit inputs. explicit inputs are the software artifacts to be inspected, the documentation and inspection aids used by the inspectors. implicit inputs include inspectors' expertise, norms, beliefs and values.
second workshop on software quality. software products are a critical and strategic asset in anorganizations' business. they are becoming larger, moresophisticated and more complex. the challenge is to developmore complicated software products within the constraints oftime and resources without the sacrifice of quality. qualitystandards, methodologies and techniques have been continuallyproposed by researchers and used by software engineers in theindustry. the second workshop on software quality aims tobring together academic, industrial and commercial communitiesinterested in software quality topics to discuss the differenttechnologies being defined and used in the software quality area.
third workshop on software quality. to develop software on time and within budget is not good enough if the software produced is full of defects. as the software market matures, users want to be assured of quality. they no longer accept claims made by the it department at face value, but expect concrete demonstrations of quality. software stakeholders are also demanding higher quality software than ever before. in recent years, much software engineering research has focussed on standards, methodologies and techniques for improving software quality, measuring software quality and software quality assurance. most of this research is focused on an internal view of quality whereas few measures of the customer view of quality exist. the third workshop on software quality aims to bring together academic, industrial and commercial communities interested in software quality topics to discuss the different technologies being defined and used in the software quality area.
the effect of modularization and comments on program comprehension. an experiment was conducted to investigate how different types of modularization and comments are related to programmers' ability to understand programs. forty-eight experienced programmers were given eight different versions of the same program and asked to answer a twenty question quiz used to measure comprehension. these eight different versions were the result of the program being constructed with four types of modularization (monolithic, functional, super, and abstract data type), each with and without comments. those subjects whose programs contained comments were able to answer more questions than those without comments. also, those subjects who were given the abstract data type version of the program were able to do significantly better than those with any other type of modularization.
ou learningworks: a customized programming environment for smalltalk modules. we have exploited and adapted goldberg's learningworks framework to produce an environment with new programming tools, visualization tools, and system simulations. the environment is designed to be used via plug-in modules, called learningbooks, sets of classes and persistent objects, for which we have developed a pedagogic standard that includes, for example, an html browser and various of the aforementioned tools and systems. the context for this development has been a distance learning degree-level course in object technology which is enrolling over 5000 mature students per year, mostly in the uk, western europe and singapore. the course, m206, computing: an object-oriented approach from the open university (ou), will soon be introduced into the usa. while adhering to the original conception of learningworks that it promote a software engineering approach of systems building, we have successfully added support for the needs of the distance learning neophyte. by showing various microworlds and programming tools these notes outline the environment we have implemented and deployed.
exploiting smalltalk modules in a customizable programming environment. this paper describes how we extended a module structure of the smalltalk learningworks framework to provide a programming environment designed for very large scale technology transfer. the 'module' is what we have termed the learningbook, a set of classes and persistent objects, including an html browser, programming and visualization tools, and microworlds. the context for this development is a distance learning university course in object technology which is enrolling over 5000 mature students per year-making it the largest such course in the world. while promoting a systems building approach, we have successfully added support for programming in the small and the needs of the isolated novice. two guiding principles have been: (i) the environment and its modules fit into a consistent structure for personal management of learning and (ii) details of complex facilities, such as the class library, are progressively disclosed as knowledge and sophistication grow. the paper shows how these principles have guided the exploitation of learningbook modules. to provide context, relevant academic background is given. early informal feedback is reported and a project currently underway to observe in detail how thousands of learners use the programming environment is sketched.
the program understanding problem: analysis and a heuristic approach. program understanding is the process of making sense of a complex source code. this process has been considered as computationally difficult and conceptually complex. so far no formal complexity results have been presented, and conceptual models differ from one researcher to the next. we formally prove that program understanding is np hard. furthermore, we show that even a much simpler subproblem remains np hard. however we do not despair by this result, but rather offer an attractive problem solving model for the program understanding problem. our model is built on a framework for solving constraint satisfaction problems, or csps, which are known to have interesting heuristic solutions. specifically, we can represent and heuristically address previous and new heuristic approaches to the program understanding problem with both existing and specially designed constraint propagation and search algorithms.
performance-related completions for software specifications. to evaluate a software specification for its performance potential, it is necessary to supply additional information, not required for functional specification. examples range from the execution cost of operations and details of deployment, up to missing subsystems and layers. the term "completions" is used here to include all such additions, including annotations, component insertions, environment infrastructure, deployment, communication patterns, design refinements and scenario or design transformations which correspond to a given deployment style. completions are related to the purpose of evaluation, so they are tailored to describing the performance at a suitable level of detail. completions for evaluating other attributes such as reliability or security are also possible. the paper describes how completions are added to a specification regardless of the language used (provided that it describes the system behaviour as well as its structure), and experience with completions in use case maps.
an architectural style for high-performance asymmetrical parallel computations. researchers with deep knowledge of scientific domains are becoming more interested in developing highly-adaptive and irregular (asymmetrical) parallel computations, leading to development challenges for both delivery of data for computation and mapping of processes to physical resources. using software engineering principles, we have developed a new communications protocol and architectural style for asymmetrical parallel computations called adapt.utilizing the support of architecturally-aware middleware, we show that adapt provides a more efficient solution in terms of message passing and load balancing than asymmetrical parallel computations using collective calls in the message-passing interface (mpi) or more advanced frameworks implementing explicit load-balancing policies. additionally, developers using adapt gain significant windfall from good practices in software engineering, including implementation-level support of architectural artifacts and separation of computational loci from communication protocols.
early experiences with euclid. the programming language euclid was designed to be used for the construction of reliable and efficient systems software. this paper discusses the authors' experience in the design and implementation of the first large (about 60,000 source lines) piece of software written in euclid. the emphasis in this paper is on how the various language features in euclid affected the implementation of the software.
overseas development for a major u.s. ecommerce website. in this paper, we describe our experience in establishing a software development center in china with the purpose of supporting a major u.s. ecommerce website. we have established a set of development processes that fit our business needs to develop a large number of relatively small projects and release them in very short intervals. our processes allow us to accurately monitor the project status, schedule resources, predict the delivery and assess the productivity. we believe only with such systems in place that businesses can ensure successful overseas software operations.
automatic extraction of abstract-object-state machines from unit-test executions. an automatic test-generation tool can produce a large number of test inputs to exercise the class under test. however, without specifications, developers cannot inspect the execution of each automatically generated test input practically. to address the problem, we have developed an automatic test abstraction tool, called abstra, to extract high level object-state-transition information from unit-test executions, without requiring a priori specifications. given a class and a set of its generated test inputs, our tool extracts object state machines (osm): a state in an osm represents an object state of the class and a transition in an osm represents method calls of the class. when an object state in an osm is concrete (being represented by the values of all fields reachable from the object), the size of the osm could be too large to be useful for inspection. to address this issue, we have developed techniques in the tool to abstract object states based on returns of observer methods, branch coverage of methods, and individual object fields, respectively. the tool provides useful object-state-transition information for programmers to inspect unit-test executions effectively. in particular, the tool helps facilitate correctness inspection, program understanding, fault isolation, and test characterization.
3d visualization for concept location in source code. the paper presents a set of tools that work in conjunction to support concept location in software. one of the tools, iriss (information retrieval based software search), is a search engine, designed and implemented to allow searching the source code of a software system. the other tool, sv3d (source viewer 3d), is a visualization front end, designed to represent software data with 3d renderings.the two tools are integrated with ms visual studio, with iriss providing the infrastructure for indexing the source code and querying, while sv3d helps the user in visually navigating the results of the queries and keeps track of the navigation path.
incremental consistency checking for pervasive context. applications in pervasive computing are typically required to interact seamlessly with their changing environments. to provide users with smart computational services, these applications must be aware of incessant context changes in their environments and adjust their behaviors accordingly. as these environments are highly dynamic and noisy, context changes thus acquired could be obsolete, corrupted or inaccurate. this gives rise to the problem of context inconsistency, which must be timely detected in order to prevent applications from behaving anomalously. in this paper, we propose a formal model of incremental consistency checking for pervasive contexts. based on this model, we further propose an efficient checking algorithm to detect inconsistent contexts. the performance of the algorithm and its advantages over conventional checking techniques are evaluated experimentally using cabot middleware.
software architecture classification for estimating the cost of cots integration. the use of commercial-off-the-shelf (cots) products creates a software integration problem, whether a single cots software component is being integrated into a software system, or the whole system is being built primarily from cots products. this integration may require considerable effort and affect system quality. a good estimate of integration cost can help in the decision of whether or not to use a cots solution, the selection of the best cots products, and determine the amount and type of glueware that needs to be built, in this paper, we introduce a set of variables that have the potential to estimate the integration cost. we present a classification scheme of software architectures with respect to the integration of cots products. the scheme is based on inter-component interactions within software architectures. the classification scheme allows the comparison of integration costs of different cots products relative to different software architectures.
the problem of knowledge decoupling in software development projects. in our ethnographic investigation of software integration projects a recurrent pattern emerges. the detailed understanding leaders have of the design and development decreases over time as they become busier and busier attending meetings, creating documents, and resolving issues and thus cannot spend much time on design or development work. as a result, their leadership becomes increasingly decoupled from the work of the project. we discuss various dimensions of this problem.
discotect: a system for discovering architectures from running systems. one of the challenging problems for software developersis guaranteeing that a system as built is consistentwith its architectural design. in this paper we describe atechnique that uses run time observations about an executingsystem to construct an architectural view of thesystem. with this technique we develop mappings thatexploit regularities in system implementation and architecturalstyle. these mappings describe how low-levelsystem events can be interpreted as more abstract architecturaloperations. we describe the current implementationof a tool that uses these mappings, and show that itcan highlight inconsistencies between implementationand architecture.
assessing cots integration risk using cost estimation inputs. most risk analysis tools and techniques require the user to enter a good deal of information before they can provide useful diagnoses. in this paper, we describe an approach to enable the user to obtain a cots glue code integration risk analysis with no inputs other than the set of glue code cost drivers the user submits to get a glue code integration effort estimate with the constructive cots integration cost estimation (cocots) tool. the risk assessment approach is built on a knowledge base with 24 risk identification rules and a 3-level risk probability weighting scheme obtained from an expert delphi analysis. each risk rule is defined as one critical combination of two cocots cost drivers that may cause certain undesired outcome if they are both rated at their worst case ratings. the 3-level nonlinear risk weighting scheme represents the relative probability of risk occurring with respect to the individual cost driver ratings from the input. further, to determine the relative risk impact, we use the productivity range of each cost driver in the risky combination to reflect the cost consequence of risk occurring. we also develop a prototype called cocots risk analyzer to automate our risk assessment method. the evaluation of our approach shows that it has done an effective job of estimating the relative risk levels of both small usc e-services and large industry cots-based applications.