waashk/dblp huggingface dataset:
formal concept analysis in software engineering. given a binary relationship between objects and attributes,concept analysis is a powerful technique to organizepairs of related sets of objects and attributes into a conceptlattice, where higher level concepts represent generalfeatures shared by many objects, while lower level conceptsrepresent the object-specific features. concept analysis wasrecently applied to several software engineering problems,such as: restructuring the code into more cohesive components,identifying class candidates, locating features in thecode by means of dynamic analysis, reengineering class hierarchies.this tutorial provides the background knowledgerequired by such applications. moreover, the methodologicalissues involved in the different applications of this techniqueare considered by giving a detailed presentation ofthree of them: module restructuring, design pattern inferenceand impact analysis based on decomposition slicing.the tutorial is concluded by an overview on other kinds ofapplications.
reverse engineering of object oriented code. during software evolution, programmers devote most of their effort to the understanding of the structure and behavior of the system. for object-oriented code, this might be particularly hard, when multiple, scattered objects contribute to the same function. design views offer an invaluable help, but they are often not aligned with the code, when they are not missing at all.this tutorial describes some of the most advanced techniques that can be employed to reverse engineer several design views from the source code. the recovered diagrams, represented in uml (unified modeling language), include class, object, interaction (collaboration and sequence), state and package diagrams. a unifying static code analysis framework used by most of the involved algorithms is presented at the beginning of the tutorial. a single running example is referred all over the presentation. trade-offs (e.g., static vs. dynamic analysis), limitations and expected benefits are also discussed.
the second international workshop on automated program analysis, testing and verification. program analysis, testing and verification are key techniques for building confidence in and increasing the quality of software systems. such activities typically cost upwards of 50% of total development costs. automation aims to allow both reduced costs and more thorough analysis, testing and verification and is vital to keep pace with increasing software complexity. this workshop follows on from the successful workshop held as part of icse 2000 in ireland to further discuss these issues and the current start-of-the-art.
software reuse myths revisited. in acm software engineering notices, vol. 13, no. 1, pp. 17-21 (1988), the author published the paper &ldquo;software reuse myths&rdquo;. this paper comments on these &ldquo;myths&rdquo; in the light of recent technology advances: (1) software reuse is a technical problem; (2) special tools are needed for software reuse; (3) reusing code results in huge increases in productivity; (4) artificial intelligence will solve the reuse problem; (5) the japanese have solved the reuse problem; (6) ada has solved the reuse problem; (7) designing software from reusable parts is like designing hardware using integrated circuits; (8) reused software is the same as reusable software; and (9) software reuse will just happen
development of a hybrid cost estimation model in an iterative manner. cost estimation is a very crucial field for software developing companies. the acceptance of an estimation technique is highly dependent on estimation accuracy. often, this accuracy is only determined after an initial application. possible further steps for improving the underlying estimation model typically do not influence the decision on whether to discard the technique or deploy it. in addition, most estimation techniques do not explicitly support the evolution of the underlying estimation model in an iterative manner. this increases the risk of overlooking some important cost drivers or data inconsistencies. this paper presents an enhanced process for developing a cobra® cost estimation model by systematically including iterative analysis and feedback cycles, and its evaluation in a software development unit of oki electric industry co., ltd., japan. during the model improvement cycles, estimation accuracy was improved from an initial 120% down to 14%. in addition, lessons learned with the iterative development approach are described.
a management approach to the development of computer-based systems. many organizations have experienced serious difficulties in developing complex computer-based systems, especially their software components. the problems include large cost overruns, schedule slippages, inadequate performance, and inability to use the system as originally envisioned. one major reason for such lack of success has been the inability of the management of the organization or the development effort to understand the need for a total-system management approach. in particular, acquisition of software and hardware separately with the hope of integrating them later does not work in complex systems. this paper outlines a management approach to acquiring computer systems which encompasses the whole system, with emphasis on the software, from the initial concept formulation to the support of the operational system. expected improvements in the development process and organizational implications of this management approach are discussed.
using web service technologies to create an information broker: an experience report. this paper reports on our experiences with using theemerging web service technologies and tools to create ademonstration information broker system as part of ourresearch into information management in a distributedenvironment. to provide a realistic context we chose tostudy the use of information in the healthcare domain,and this context sets some challenging parameters andconstraints for our research and for the demonstrationsystem. in this paper we both report on the extent towhich existing web service technologies have proved tobe mature enough to meet these requirements, and alsoassess their current limitations.
the software factory: combining undergraduate computer science and software engineering education. industry often complains that current university curricula fail to address the practical issues of real software development. this paper outlines a proposal for an innovative core curriculum for a bachelor of science in computer science. the proposed core curriculum contains elements of traditional computer science programs combined with software engineering via a team-oriented, hands-on approach to large-scale software development. in addition to traditional lecture/project/exam courses, students are required to take an eight-semester sequence of &ldquo;software factory&rdquo; courses. software factory courses put the students' newly acquired skills to work in a real software organization staffed and managed by all students in the program. students from all courses in the software factory sequence meet simultaneously to fulfill their roles in the software organization. we expect the students will be better-prepared software engineering practitioners after completing a curriculum that combines traditional courses with practical software factory experience.
ensemble of missing data techniques to improve software prediction accuracy. software engineers are commonly faced with the problem of incomplete data. incomplete data can reduce system performance in terms of predictive accuracy. unfortunately, rare research has been conducted to systematically explore the impact of missing values, especially from the missing data handling point of view. this has made various missing data techniques (mdts) less significant. this paper describes a systematic comparison of seven mdts using eight industrial datasets. our findings from an empirical evaluation suggest listwise deletion as the least effective technique for handling incomplete data while multiple imputation achieves the highest accuracy rates. we further propose and show how a combination of mdts by randomizing a decision tree building algorithm leads to a significant improvement in prediction performance for missing values up to 50%.
silver bullet or fool's gold: supporting usability in open source software development. at first glance it can look like open source software development violates many, if not all, of the precepts of decades of careful research and teaching in software engineering. one could take a classic se textbook and compare the activities elaborated and advocated in the various chapters with what is actually done in plain sight in the public logs of an oss project in say sourceforge. for a professor of software engineering this might make for rather depressing reading. are the principles of se being rendered obsolete? has oss really discovered brooks' silver bullet? or is it just a flash in the pan or fool's gold.in this talk i will mainly look at one aspect of open source development, the 'problem' of creating usable interfaces, particularly for non-technical end-users. any approach involves the challenge of how to coordinate distributed collaborative interface analysis and design, given that in conventional software development this is usually done in small teams and almost always face to face. indeed all the methods in any hci text just assume same-time same-place work and don't map to distributed work, let alone the looser mechanisms of oss development. instead what is needed is a form of participatory usability involving the coordination of end users and developers in a constantly evolving redesign process.
a workbench for synthesising behaviour models from scenarios. scenario-based specifications such as message sequence charts (mscs) are becoming increasingly popular as part of a requirements specification. our objective is to facilitate the development of behaviour models in conjunction with scenarios. in this paper, we first present an msc language with semantics in terms of labelled transition systems and parallel composition. the language integrates existing languages based on the use of high-level mscs (hmscs) and on identifying component states. this integration allows stakeholders to break up scenario specifications into manageable parts using hmcss and to explicitly introduce additional information and domain-specific or other assumptions using state labels. secondly, we present an algorithm, implemented in java, which translates scenarios into a specification in the form of finite sequential processes. this can then be fed to the labelled transition system analyser for model checking and animation. finally we show how many of the assumptions embedded in existing synthesis approaches can be translated into our approach. thus we provide the basis of a common workbench for supporting msc specifications, behaviour synthesis and analysis.
a cooperative approach to software development by application engineers and software engineers. we have tried a new project management approach for the development of engineering application software systems. the key factor of this new approach is the introduction of the role of &ldquo;interpreter&rdquo; who sits in between application engineers and programmers and handles all of the communication problems among them. our major objectives were: (1) to release application engineers from unfamiliar programming tasks as much as possible. (2) and to increase the productivity of a small group of technical staffs. experiments upon real projects resulted in much greater improvement of productivity and quality than we had expected. and also the morale of team members was improved. this paper describes the results of these experiments and the characteristics of this new development approach in comparison with the traditional one.
modeling software for accurate data flow representation. a particular model used for data flow oriented structural testing is the def-use graph which captures intraprocedural data flow dependencies within the control flow exhibited by a program written in a procedural language. since procedures in a program are closely interrelated, data flow oriented structural testing must also be performed at the program level utilizing the interprocedural data flow dependencies. the authors point out that the accuracy of the representation of data flow dependencies by the def-use graph is no longer acceptable at the program level where the accurate representation of interprocedural data flow dependencies is needed. this point is illustrated by an error that cannot be revealed by existing data flow oriented test path selection criteria when the procedures of a program are considered individually, but can be revealed by at least two of the criteria which require accurate representation of interprocedural data flow dependencies. a new model, called the extended def-use graph is proposed to represent both intraprocedural and interprocedural data flow dependencies in the control flow exhibited by a program. this model facilitates the application of the existing data flow oriented test path selection criteria at the program level
software development with executable functional specifications. the descartes specification language and support software provides a tool for developing and executing functional specifications. a variety of specifications have been developed to support the language design and evaluation. in addition, the language has been applied to the development of a large specification. current research efforts include: specification development, support software enhancements, and software life cycle impact. an overview of the specification language is included in this paper. the language processor for descartes is described in relation to providing the capability for executing specifications. program development and testing with respect to utilizing descartes is outlined.
using process technology to control and coordinate software adaptation. we have developed an infrastructure for end-to-end run-time monitoring, behavior/performance analysis, and dynamic adaptation of distributed software. this infrastructure is primarily targeted to pre-existing systems and thus operates <u>outside</u> the target application, without making assumptions about the target's implementation, internal communication/computation mechanisms, source code availability, etc. this paper assumes the existence of the monitoring and analysis components, presented elsewhere, and focuses on the mechanisms used to control and coordinate possibly complex repairs/reconfigurations to the target system. these mechanisms require lower-level effectors somehow attached to the target system, so we briefly sketch one such facility (elaborated elsewhere). our main contribution is the model, architecture, and implementation of workflakes, the decentralized process engine we use to tailor, control, coordinate, etc. a cohort of such effectors. we have validated the workflakes approach with case studies in several application domains. due to space restrictions we concentrate primarily on one case study, briefly discuss a second, and only sketch others.
experience with the development of hard real-time embedded ada software. though already intrinsically demanding, the development of real-time embedded on-board software is often made harsher by the constraining nature of the execution environment and the general lack of suitable support. one of the key needs in the design of these systems is to get guidance towards the definition of a system that is truly analysable against timing requirements; specialised methods and tools are needed to accommodate this particular demand. this paper reports on the use of a novel design method especially tailored towards the construction of hard real-time systems
engineering the software requirements of nonprofits: a service-learning approach. this paper is a cross-study of service-learning projects executed by student groups in a 10-week course on software engineering. the principal benefits of service-learning are demonstrated by the groups in this setting. the course is structured to support the project activities; timely brainstorming and negotiation roleplay exercises help the teams arrive at pragmatic baselines with their clients. the study highlights overlaps in the software requirements of nonprofits. the paper apprises the reader of some common mistakes committed by the various stakeholders, some of which can eventually undermine the project's mission.
jungl: a scripting language for refactoring. refactorings are behaviour-preserving program transformations, typically for improving the structure of existing code. a few of these transformations have been mechanised in interactive development environments. many more refactorings have been proposed, and it would be desirable for programmers to script their own refactorings. implementing such source-to-source transformations, however, is quite complex: even the most sophisticated development environments contain significant bugs in their refactoring tools.we present a domain-specific language for refactoring, named jungl. it manipulates a graph representation of the program: all information about the program, including asts for its compilation units, variable binding, control flow and so on is represented in a uniform graph format. the language is a hybrid of a functional language (in the style of ml) and a logic query language (akin to datalog). jungl furthermore has a notion of demand-driven evaluation for constructing computed information in the graph, such as control flow edges. borrowing from earlier work on the specification of compiler optimisations, jungl uses so-called `path queries' to express dataflow properties.we motivate the design of jungl via a number of non-trivial refactorings, and describe its implementation on the.net platform.
five years of product line engineering in a small company. in 1999, a new team at market maker software ag began to develop a software product line for managing and displaying stock market data and financial market news. the basic idea was to use web technology in all applications for delivering services to customers. it soon turned out that the company had to change both the processes and the organization. this report summarizes the changes made and the lessons learned over the past five years, when the product line idea was introduced into a small company which faced the pressure to quickly market the first product line instances.
a methodology and tool for performance analysis of distributed server systems. we present a methodology and tool for performance analysis of distributed server systems, which allows high-level specification of the system, and generates and solves the underlying queueing network model. our approach is different from the existing ones in that the specification captures the natural manner in which application servers are deployed on machines and machines are deployed on networks. the model does not impose any strict tiers on the server system. multiple use case scenarios can be specified, and the tool computes measures such as end-to-end response times for each scenario while taking into account queueing delays at the hardware device, software threads and at the network. the development of the tool is ongoing, and will include detailed network protocol models as well as more flexible distributed system behavior, in the future.
analyzing software architectures with argus-i. this formal research demonstration attempts to present an approach to develop and assess architecture and component-based systems based on specifying software architecture augmented by statecharts representing component behavioral specifications [1]. the approach is applied for the c2 style [2] and associated adl and is supported within a quality-focussed environment, called argus-i, which assists specification-based analysis and testing at both the component and architecture levels.
introduction to corba (tutorial session). this tutorial provides the basics that developers need to begin understanding the common object request broker architecture (corba) and using it to write industrial-strength distributed systems. you will learn about the basics of the object management group's (omg) object management architecture (oma), with a focus on its corba component. by the end of the tutorial, you will understand how to write object interface specifications using the omg interface definition language (idl), how to write simple distributed applications in c++, how to use the portable object adapter (poa), the dynamic invocation interface (dii) and the dynamic skeleton interface (dsi), and the interface repository (ifr). you will also know the basics of several corba services such as naming, trading, and events.
scalability issues in corba-based systems (tutorial session). this tutorial addresses how both the object management group (omg) specifications and the implementation choices made by middleware providers and application developers affect common object request broker architecture (corba) application scalability. we will cover a range of scalability issues, starting with object request broker (orb) internals and working outward to full-scale applications, addressing issues such as connection management, portable object adapter (poa) scalability features, multithreading, object lifecycle issues, object location, system configuration, maintenance, and management, and common application architectures. this tutorial is not language-centric and is useful to developers using java, c++, or any other language to develop corba-based applications.
the multics system programming process. features of the multics system programming process lead to high programmer productivity with a small programming staff and a finished system with high software reliability. other workers' predictions of increasing difficulty of system maintenance with time have not been observed; reasons for this are suggested.
some myths of software engineering education. based on many years of teaching software engineering, i present a number of lessons i have learned over the years. i do so in the form of a series of myths, the reverse of which can be considered challenges to educators. the overall message i wish to convey is that there's more to software engineering than engineering. the engineering metaphor gives us a lot of useful guidance in shaping our profession. but there's also a downside, in that this goes at the expense of the human, social dimension that is an essential element of our profession.
aspects of design, test and validation of the software for a computerized reactor protection system. in safety-oriented applications, the software has to fulfil certain stringent reliability requirements. in order to determine the reliability of the software, a variety of different methods can be used. the methods used for the reliability proof of a computerized reactor protection system are discussed in this paper. in addition to the constructive approach with structured programming, defensive programming and other guidelines also concerning the operating system, the analytical approach is taken. this includes the use of an automatic test system for statical and dynamical analysis of the software and automatic test data generation. finally, a systemtest is conducted, where test data are produced according to the process and the results are compared with the results of a simulation model.