waashk/dblp huggingface dataset:
software engineering challenges: a cio's perspective. to be competitive in today's market, businesses face many challenges in the development and maintenance of information systems. these systems are usually widely distributed. they incorporate highly critical corporate knowledge, which has to be easily accessible and maintainable. engineering these large systems efficiently requires making decisions about a number of issues. decisions about whether to build or buy software affect qualities of the software such as customization and reusability, and decisions about mobility of services affect qualities of the software such as maintainability. moreover, for improved reliability, techniques that can provide seamless but secure and reliable information flow and transaction processing, although expensive, must be integrated into the development process. finally, systems must be adaptable to new technologies such as wireless computing. old existing legacy software has to be integrated with new web-based applications such as portals or the whole world of &ldquo;e&rdquo;.
software templates. software components often cannot be reused since the algorithms they realize are encoded in terms of particular implementations. this paper presents an approach to reusability where algorithms and implementations are specified separately. an algorithm is specified by a sequence of recursion equations called a software template. templates are defined over values of abstract data types whose implementations are specified separately and catalogued. when a template's data types are bound to catalogued implementations, the template is automatically translated into a component tailored to the chosen implementations, a process called template instantiation. different implementations of an algorithm can be achieved by merely binding the data types of its template, specification to different implementations.
productivity factors and programming environments. fourteen factors that influence the efficiency of programming projects were identified in a corporate-wide study of 44 itt programming projects in nine countries. productivity factors were classified according to project management's ability to control them. product-related factors are not generally under the control of project management. they describe intrinsic properties of the programming product and tend to place limitations on achievable productivity. project-related factors, on the other hand, are controllable by project management to varying degrees. these factors provide real opportunities for productivity improvement. the analysis indicates that productivity variation is almost equally attributable to product-related and project-related factors.
an initial assessment of aspect-oriented programming. the principle of separation of concerns has long been used by software engineers to manage the complexity of software system development. programming languages help software engineers explicitly maintain the separation of some concerns in code. as another step towards increasing the scope of concerns that can be captured cleanly within the code, kiczales and colleagues have introduced aspect-oriented programming. in aspect-oriented programming, explicit language support is provided to help modularize design decisions that cross-cut a functionally-decomposed program. aspect-oriented programming is intended to make it easier to reason about, develop, and maintain certain kinds of application code. to investigate these claims, we conducted two exploratory experiments that considered the impact of aspect-oriented programming, as found in aspectj version 0.1, on two common programming activities: debugging and change. our experimental results provide insights into the usefulness and usability of aspect-oriented programming. our results also raise questions about the characteristics of the interface between aspects and functionally-decomposed core code that are necessary to accrue programming benefits. most notably, the separation provided by aspect-oriented programming seems most helpful when the interface is narrow (i.e., the separation is more complete); partial separation does not necessarily provide partial benefit.
methods of component-based software engineering: essential concepts and classroom experience. the crucial role of software components in the construction of enterprise information management systems is now manifest. notwithstanding this, the implication of software components on software engineering methods is not well understood by many practitioners. this tutorial explores the implications of two classes of component-based development efforts. first, those efforts where components are custom-developed and deployed onto a pre-fabricated component infrastructure such as enterprise javabeanstm, and second, efforts where commercial off-the-shelf components are integrated into an enterprise infrastructure upon which business logic can be deployed.
architectural level risk assessment tool based on uml specifications. recent evidences indicate that most faults in software systems are found in only a few of a system's components [1]. the early identification of these components allows an organization to focus on defect detection activities on high risk components, for example by optimally allocating testing resources [2], or redesigning components that are likely to cause field failures. this paper presents a prototype tool called architecture-level risk assessment tool (arat) based on the risk assessment methodology presented in [3]. the arat provides risk assessment based on measures obtained from unified modeling language (uml) artifacts [4]. this tool can be used in the design phase of the software development process. it estimates dynamic metrics [5] and automatically analyzes the quality of the architecture to produce architectural-level software risk assessment [3].
bsr: a statistic-based approach for establishing and refining software process performance baseline. high-level process management is quantitative management. the process performance baseline (ppb) of process or subprocess under statistical management is the most important concept. it is the basis of process control and improvement. the existing methods for establishing process baseline are too coarse-grained or have some limitation, which lead to inaccurate or ineffective quantitative management. in this paper, we propose an approach called bsr (baseline-statistic-refinement) for establishing and refining software process performance baseline, and present the experience result to validate its effectiveness for quantitative process management.
a worldwide survey of base process activities towards software engineering process excellence. a survey has been designed to seek the practical foundation of base process activities (bpas) in the software industry and to support research in modelling the software engineering processes. a superset of bpas compatible with the current software process models, such as spice (iso 15504), cmm, iso 9000 and bootstrap, were identified for the construction of the questionnaires. this paper reports the survey findings on bpas in software engineering processes. a summary of the current software engineering process techniques and practices modelled by 83 bpas in 10 processes and three categories is given. each bpa is benchmarked on attributes of mean importance and ratios of significance, practice and effectiveness. based on the benchmarks, and by comparing with the current practice of the reader's organization, recommendations can be given on which specific areas need to have processes established first, and which areas should be highest priority for process improvement
simulating the behaviour of software modules by trace rewriting. the trace assertion method is a module interface specification method based on the finite state machine model. to support this method, we plan to develop a specification simulation tool, a trace simulator, that symbolically interprets trace assertions of trace specifications and simulates the externally observable behavior of the modules specified. we first present the trace assertion method. then we formally define trace rewriting systems and show how trace rewriting, a technique similar to term rewriting, can be applied to implement trace simulation.
using compressed bytecode traces for slicing java programs. dynamic slicing is a well-known program debuggingtechnique. given a program p and input i, it finds all programstatements which directly/indirectly affect the valuesof some variablesý occurrences when p is executed with i.dynamic slicing algorithms often proceed by traversing theexecution trace of p produced by input i (or a dependencegraph which captures control/data flow in the executiontrace). consequently, it is important to develop space efficient representations of the execution trace.in this paper, we use results from data compression tocompactly represent bytecode traces of sequential java programs.the major space savings come from the optimizedrepresentation of data (instruction) addresses used by memoryreference (branch) bytecodes as operands. we give detailedexperimental results on the space efficiency and timeoverheads for our compact trace representation. we thenshow how dynamic slicing algorithms can directly traverseour compact traces without resorting to costly decompression.we also develop an extension of dynamic slicing whichallows us to explain omission errors (i.e. why some eventsdid not happen during program execution).
reengineering standalone c++ legacy systems into the j2ee partition distributed environment. many enterprise systems are developed in c++ language and most of them are standalone. because the standalone software can not follow the new market environment, reengineering the standalone legacy systems into distributed environment becomes a critical problem. some methods have been proposed on related topics such as design recovery, the identification of the component, modeling the interfaces of components and components allocation. up to now, there does not exist a reengineering process for partition distributed environment, which will offer distinct advantages on horizontal scalability and performance over normal distributed solutions. this paper presents a new process to reengineer c++ legacy systems into the j2ee partition distributed environment. the process consists of four steps: translation from c++ to java code; extraction of components using the cluster technology; modeling component interfaces and partition of the components in j2ee distribute environment. it has been applied to a large equity-trading legacy system which has proved to be successful.
system challenges for ubiquitous & pervasive computing. the terms ubiquitous and pervasive computing were first coined at the beginning of the 90's, by xerox parc and ibm respectively, and capture the realization that the computing focus was going to change from the pc to a more distributed, mobile and embedded form of computing. furthermore, it was predicted by some researchers that the true value of embedded computing would come from the orchestration of the various computational components into a much richer and adaptable system than had previously been possible. now some fifteen years later, we have made progress towards these aims. the hardware platforms used to implement these systems encapsulate significant computation capability in a small form-factor, consume little power and have a small cost. however, the system software capabilities have not advanced at a pace that can take full advantage of this infrastructure. this paper will describe where software and hardware have combined to enable ubiquitous computing, where these systems have limitations and where the biggest challenges still remain.
map: a tool for understanding software. maintenance of software is a major problem that the data processing industry faces today. this paper describes map, a tool, that addresses the problems of software maintenance by helping programmers to understand their programs.
experience with a module package in developing production quality pascal programs. a module package (amp) is a preprocessor to a pascal compiler to support data encapsulation and modular system development. experience with amp in developing a software product at amdahl corporation has demonstrated its utility and robustness.
experiments on quality evaluation of embedded software in japan robot software design contest. as a practical opportunity for educating japanese young developers in the field of embedded software development, a software design contest involving the design of software to automatically control a line-trace robot, and conduct running performance tests was held. in this paper,we give the results of the contest from the viewpoint of software quality evaluation. we create a framework for evaluating the software quality which integrated design model quality and the final system performance, and conduct analysis using the framework. as a result of analysis,it is found that the quantitative measurement of the structural complexity of the design models bears a strong relationship to qualitative evaluation of the design conducted by judges. it is also found that there is no strong correlation between design model quality evaluated by the judges and the final system performance. for embedded software development, it is particularly important to estimate and verify reliability and performance in the early stages,using the model. based on the analysis result,we consider possible remedies with respect to the models submitted,the evaluation methods used and the contest specifications. in order to adequately measure several non-functional quality characteristics including performance on the model,it is necessary to improve the way of developing robot software (such as applying model driven development)and reexamine the evaluation methods.
reuse facts and myths. this paper on software reuse is the view of a practitioner rather than of a scientist. myth 1: oo technology eats up reuse. fact 1: oo does not automatically yield high reuse rates-both oo and reuse can complement each other. myth 2: incentives are key to reuse success. fact 2: incentives create awareness, are cheap but don't change much. myth 3: reuse is for free. fact 3: reuse is a mid-term investment impacting the entire software development process. it must be based on a product strategy which spans several releases or a family of products
user software engineering and the design of interactive systems. the successful construction of interactive systems requires the utilization of principles of user-centered design, combined with techniques for software engineering, in order to produce systems that are reliable, easy to use, and well adapted to user needs. this paper presents some of these principles and shows how they are achieved in the user software engineering (use) project, which is intended to provide the applications developer with a development environment that supports the systematic specification and implementation of interactive systems.
a specification-based adaptive test case generation strategy for open operating system standards. the paper presents a specification based adaptive test case generation (sbatcg) method for integration testing in an open operating system standards environment. in the sbatcg method, templates describing abstract state transitions are derived from a model based specification, and the templates are refined to the internal structure of each implementation. we adopt the z notation, one of the most widely used formal specification languages. we conducted mutation analysis to study the fault exposure abilities of the sbatcg method and that of a strategy based only on a specification. in our experiment, we used a z version of the itron2 real time multi task operating system specification and two commercially available itron2 implementations. the results of this equipment show that the sbatcg method can achieve a higher fault detecting ability than can the strategy using only a specification.
brazilian software quality in 2002. brazil aims to achieve international standards on quality and productivity in the software sector. from 1993 onwards there are strategies and projects to reach the brazilian objective on software quality. since 1995 there have been nationwide surveys on software quality every 2 years. this paper highlights the main trends on software quality in brazil based both on the results of four surveys (1995, 1997, 1999, and 2001) and on other pieces of evidence. the paper concludes that the software quality in brazil is continuously improving.
research pradigms in computer science. this paper explores the ramifications of four influential definitions of computer science: 1. computer science is the study of phenomena related to computers, newell, perlis and simon, 1967 2. computer science is the study of algorithms, knuth, 1968 3. computer science is the study of information structures, wegner, 1968, curriculum 68 4. computer science is the study and management of complexity, dijkstra, 1969. the first definition reflects an empirical tradition since it asserts that computer science is concerned with the study of a class of phenomena. the second and third definitions reflect a mathematical tradition since algorithms and information structures are two abstractions from the phenomena of computer science. the fourth definition reflects the great complexity of engineering problems encountered in managing the construction of complex software-hardware systems. it is argued in section 1 that computer science was dominated by empirical research paradigms in the 1950s, by mathematical research paradigms in the 1960s and by engineering oriented paradigms in the 1970s. section 2 illustrates how these three phases of development are reflected in the field of programming languages. the remaining sections consider in greater detail how empirical, mathematical and engineering research paradigms have affected the development of computer science. section 3 indicates that although the phenomena of computer science are created by man they can be studied using the empirical techniques of the natural sciences. section 4 distinguishes between &ldquo;micro computer science&rdquo; concerned with the study of individual algorithms and &ldquo;macro computer science&rdquo; concerned with the study of mechanisms and notations for specifying all algorithms; and between intensional &ldquo;how&rdquo; specifications and extensional &ldquo;what&rdquo; specifications for programs and computing systems. section 5 distinguishes between the uses of the term &ldquo;complexity&rdquo; in software engineering and the analysis of algorithms and suggests that different terms be used to denote these two kinds of complexity. in a final section it is argued that the diversity of research paradigms in computer science may be responsible both for our difficulties in deciding how computer scientists should be trained and for divergences of opinion concerning the nature of computer science research.
research directions in software technology. this paper reports on the results of a study, sponsored by afosr, aro and onr, of current and future research directions in technological areas of computer science. this study is similar in spirit to the nsf-sponsored cosers (computer science and engineering research study) project, but is narrower in scope, emphasizing concepts and research issues relevant to software technology rather than the whole spectrum of research directions in computer science. it was started in the summer of 1975 and has resulted in a book to be published by the mit press in the summer of 1978. section 1 of this paper discusses the objectives and organization of the book and introduces a framework for structuring the subject matter of software technology which parallels the structure of the book. sections 2 and 3 respectively discuss the impact on research of the changing technological environment and the unusual nature of software products. sections 4-7 present a detailed summary of the contributions of individual chapters. section 8 enumerates research directions for each of the areas considered. section 9 briefly considers time horizons and funding philosophies.
evaluating software development environments. the purpose of defining a methodology for evaluating software development environments is to add a degree of rigor and standardization to the process in much the same way as benchmark test suites do for evaluating certain hardware and software. the methodology developed at the software engineering institute is user-oriented, comprehensive, repeatable, extensible, and partly environment independent. it has been used to evaluate several ada environments so that they may be compared objectively according to the same criteria.the methodology is based on the underlying activities of software engineering since it focuses on the support of key software lifecycle activities rather than on adherence to a pre-existing tool taxonomy. the following paragraphs briefly describe the steps of each of the six phases of the methodology. the first three phases are independent of any particular environment and the last three are repeated for each environment evaluated.
overstructured management of software engineering. poor management can increase software costs more rapidly than any other factor, yet few studies have been made of poor management. one model suggests that poor management may arise from overly structured thinking on the part of software engineers who become managers after achieving technical success.
quality of service engineering with uml, .net, and corba. the concern for non-functional properties of software components and distributed applications has increased significantly in recent years. non-functional properties are often subsumed under the term quality of service (qos). it refers to quality aspects of a software component or service such as real-time response guarantees, availability, and fault-tolerance, the degree of data consistency, the precision of some computation, or the level of security. consequently, the specification and implementation of qos mechanisms has become an important concern in the engineering of distributed applications. in this tutorial the attendees will learn how non-functional requirements can be engineered in a systematic way into applications on top of distribution platforms such as corba and .net. the tutorial focuses on two major subjects areas: (1) specification of qos properties and (2) implementation of qos mechanisms in middleware. we present a comprehensive, model-driven approach. it starts with a platform-independent model (pim) in uml that captures the application qos requirements. this model is mapped by a tool to a platform-specific model (psm) tailored for a specific middleware, which is extended with the corresponding qos mechanisms. finally, the psm is translated to code. participants in this tutorial will get a thorough understanding of general qos requirements, qos modeling alternatives and qos mechanism integration in respect to popular distributed object middleware. furthermore, we will discuss the pros and cons of corba and .net for qos engineering. a tool will be demonstrated that eases substantially the modeling stages and the code generation.
program slicing. program slicing is a method used by experienced computer programmers for abstracting from programs. starting from a subset of a program's behavior, slicing reduces that program to a minimal form which still produces that behavior. the reduced program, called a &ldquo;slice&rdquo;, is an independent program guaranteed to faithfully represent the original program within the domain of the specified subset of behavior. finding a slice is in general unsolvable. a dataflow algorithm is presented for approximating slices when the behavior subset is specified as the values of a set of variables at a statement. experimental evidence is presented that these slices are used by programmers during debugging. experience with two automatic slicing tools is summarized. new measures of program complexity are suggested based on the organization of a program's slices.