waashk/dblp huggingface dataset:
panel: perspectives on software engineering. this panel gives a non-standard view of the future of software engineering. two of the speakers are recent ph.d. graduates in computer science, with expertise in software engineering, who have taken academic positions; as people who will educate the next generation of software engineering practitioners and researchers, they provide a key vision of the future. the other two speakers are senior, having moved from the research community into a world in which they face the problems of engineering software on a daily basis. collectively, along with interactions from the audience, these two often underrepresented perspectives provide a sense of the key directions in which software engineering&mdash; practice, research, and education&mdash;should and must go.
extension and software development. enhancement is the most costly phase of the software development life-cycle. by developing an extension mechanism that allows users to augment a software system without modifying the underlying source code, we address enhancement directly. we describe the design and implementation of the extension mechanism. we also demonstrate how the availability of this flexible mechanism alters not only the enhancement phase of the life-cycle, but the design and implementation phases as well.
an evaluation of required element testing strategies. in this paper we discuss required element testing strategies and present some experimental evaluations of their effectiveness. these strategies use data flow analysis as a basis for developing test cases. the basic strategy (required pairs) is compared with random and branch testing using mutation analysis as a measure of test set effectiveness. extensions of the basic strategy are also studied.
analysis of multi-agent systems based on kaos modeling. the purpose of this study is to reduce the gap between the requirement analysis and analysis phases of developing multi-agent systems. we utilize kaos, one of the goal-oriented analysis methodologies, as a requirement analysis method, and propose a model translation into an analysis model for simple and effective development of multi-agent systems.
supporting reuse by delivering task-relevant and personalized information. technical, cognitive, and social factors inhibit the widespread success of systematic software reuse. our research is primarily concerned with the cognitive and social challenges faced by software developers: how to motivate them to reuse and how to reduce the difficulty of locating components from a large reuse repository. our research has explored a new interaction style between software developers and reuse repository systems enabled by information delivery mechanisms. instead of passively waiting for software developers to explore the reuse repository with explicit queries, information delivery autonomously locates and presents components by using the developers' partially written programs as implicit queries.we have designed, implemented, and evaluated a system called codebroker, which illustrates different techniques to address the essential challenges in information delivery: to make the delivered information relevant to the task-at-hand and personalized to the background knowledge of an individual developer. empirical evaluations of codebroker show that information delivery is effective in promoting reuse.
detecting low usability web pages using quantitative data of users' behavior. the purpose of this research is to detect low usability web pages from the behavior of users, such as browsing time, mouse movement and eye movement. we experimented to investigate the relation between the quantitative data viewing behavior of users and web usability evaluation by subjects. we analyzed the data to detect low usability web pages using discriminant analysis. low usability web pages, 94.4% (17pages / 18pages = detectable pages / low usability pages) were detectable from the moving speed of gazing points and the amount of wheel rolling of a mouse. moreover, this detection reduced the number of web pages which should be evaluated by half (46% = 89 pages / 192 pages = detected pages / all pages).
call-mark slicing: an efficient and economical way of reducing slice. when one debugs and maintain large software, it is very important to localize the scope of concern to small program portions. program slicing is a promising technique for identifying portions of interest. there are many research results on the program slicing method. x static slice, which is a collection of program statements possibly affecting a particular variable's value, limits the scope, but the resulting collections are often still large. a dynamic slice, which is a collection of executed program statements affecting a particular variable's value, generally reduces the scope considerably, but its computation is expensive since the execution trace of the program must be recorded. in this paper, we propose a new slicing technique named call-mark slicing that combines static analysis of a program's structure with lightweight dynamic analysis. the data dependences and control dependences among the program statements are statically analyzed beforehand, and procedure/function invocations (calls) are recorded (marked) during execution. from this information, the dynamic dependences of the variables are explored. this call-mark slicing mechanism has been implemented, and the effectiveness of the method has been investigated.
an editor for documentation in pi-system to support software development and maintenance. a lot of information necessary to maintain a software tends to be lost in conventional documentation. one of the leading causes is considered that the ideas of developers which maintainers will want to know later are not fixed in any documents while the ideas are fresh. to remove the cause, we propose a new description form, called a frame, and construct a system called &pgr;, to support a software through its lifetime. this system gathers all the information with the frames, stores it in a database and provides the various services with respect to programming and documentation. this paper describes the frames and a subsystem, called &pgr;-editor, which provides a user friendly interface to make it easy to gather essential information. by using frames, (1) the associated information around one programming concept can be gathered at one time and (2) lack of necessary information hardly arises. the editor has the distinguished features such as (1) a structure-oriented display editor, (2) facilities to display selective information, provide helpful user guides, and check input errors immediately.
technology transfer macro-process: a practical guide for the effective introduction of technology. in our efforts to increase software development productivity, we have worked to introduce numerous software development techniques and technologies into various target organizations. through these efforts, we have come to understand the difficulties involved in technical transfer. some of the major hurdles that these organizations face during technical transfers are tight schedules and budgets. we have made efforts to lighten this load by using various customization techniques and have defined an overall process called the technology transfer macro-process that we can use to introduce a wide variety of software development techniques and technologies into a target organization.this paper introduces this simple and practical process along with important methods and concepts such as the process plug-in method and the process warehouse, for the introduction of new tools, technologies, and processes within an organization. the issue of initial productivity loss will also be discussed and a suggestion on how to avoid this will be made. these methods have been successfully used to introduce object-oriented technology (oot) into actual development projects and have helped to increase overall productivity within the target development organizations.
static analysis-based program evolution support in the common lisp framework. the common lisp framework(clf) is an object-oriented environment to support the development and maintenance of programs written in the language common lisp. a static analysis tool, which is part of clf, supports program evolution in clf. since the effectiveness of our approach stems from the basic design and architecture of clf, we provide an overview of the relevant features of clf. the static analysis tool asserts the static properties of program objects definitions into the clf objectbase. clf's general mechanism to add rules to the objectbase provides the conceptual basis to respond to changes in the static properties of program objects in several interesting ways &mdash; from programming routine responses to program changes to viewing program alterations idiomatically.
viewpoints: meaningful relationships are difficult! the development of complex systems invariably involves many stakeholders who have different perspectives on the problem they are addressing, the system being developed, and the process by which it is being developed. the viewpoints framework was devised to provide an organisational framework in which these different. perspectives, and their relationships, could be explicitly represented and analysed. the framework acknowledges the inevitability of multiple inconsistent views, promotes separation of concerns, and encourages decentralised specification while providing support for integration through relationships and composition. in this paper, we reflect on the viewpoints framework, current work, and future research directions.
data flow analysis for checking properties of concurrent java programs. in this paper we show how the flavers data flow analysis technique, originally formulated for programs with the rendezvous model of concurrency, can be applied to concurrent java programs. the general approach of flavers is based on modeling a concurrent program as a flow graph and using a data flow analysis algorithm over this graph to check statically if a property holds on all executions of the program. the accuracy of this analysis can be improved by supplying additional information, represented as finite state automata, to the data flow analysis algorithm. in this paper we present a straightforward approach for modeling java programs that uses the accuracy improving mechanism to represent the possible communications among threads in java programs, instead of representing them directly in the flow graph model. we also discuss a number of error-prone thread communication patterns that can arise in java and describe how flavers can be used to check for the presence of these.
the echo approach to formal verification. in this research abstract, we propose echo: a general formal verification approach that combines theorem proving, model checking, and code-level tools to show an implementation's compliance with its formal specification. we believe that this approach is novel since the major proof step is carried out between two abstract specification models, thus avoiding or mitigating the difficulty of the direct compliance proof of a concrete implementation against an abstract formal specification in traditional floyd-hoare verification. we present our prototype design and implementation of the major components of the approach and we instantiate the approach to verify spark ada implementations against pvs specifications. we conducted an initial experiment to determine the feasibility of the approach using a hypothetical avionics system.
expressing the relationships between multiple views in requirements specification. the authors generalize and formalize the definition of a viewpoint to facilitate its manipulation for composite system development. a viewpoint is defined to be a loosely-coupled, locally managed object encapsulating representation knowledge, development process knowledge and partial specification knowledge about a system and its domain. in attempting to integrate multiple requirements specification viewpoints, overlaps must be identified and expressed, complementary participants made to interact and cooperate, and contradictions resolved. the notion of inter-viewpoint communication is addressed as a vehicle for viewpoint integration. the communication model presented straddles both the method construction stage during which inter-viewpoint relationships are expressed, and the method application stage during which these relationships are enacted
living assistance systems: an ambient intelligence approach. in this paper, we present an integrated system concept for the living assistance domain based on ambient intelligence technology and discuss the resulting challenges for the software engineering discipline. automated living assistance systems represent a promising approach for the prolongation of an independent and self-conducted life of handicapped and elderly people thereby, enhancing their quality of life and minimizing the need for manual social/medical care. it is demonstrated that living assistance systems must realize flexibility and adaptability at the algorithmic, architectural and human interface level to an extent unknown in present systems. the construction of robust, trustworthy living assistance systems is an extremely challenging task and requires novel approaches for dependable self-adapting software architectures, resource efficiency, and self-adapting multi-modal human-computer interfaces. the resulting consequences and challenges for the discipline of software engineering are outlined in this paper.
consistency management with repair actions. comprehensive consistency management requires a strong mechanism for repair once inconsistencies have been detected. in this paper we present a repair framework for inconsistent distributed documents. the core piece of the framework is a new method for generating interactive repairs from full first order logic formulae that constrain these documents. we present a full implementation of the components in our repair framework, as well as their application to the uml and related heterogeneous documents such as ejb deployment descriptors. we describe how our approach can be used as an infrastructure for building higher-level, domain specific frameworks and provide an overview of related work in the database and software development environment community.
software development and proofs of multi-level security. this paper summarizes current research at ri aimed at developing secure operating systems and verifying certain critical properties of these systems. it is seen that proofs of design properties can be relatively straightforward when the design is specified in suitable formal specification language. these proofs demonstrate the correspondence between the desired properties and a specification of the system design. various on-line tools aid considerably in this process. in addition, correctness proofs for implementations of such systems are now feasible, because of both various theoretical advances and the use of supporting tools.
introduction to agile processes and extreme programming. extreme programming is one of the most discussed subjects in the software development community. but what makes xp extreme? and how does it fit into the new world of agile methodologies? this tutorial will establish the underpinnings of agile methodology and explain why you might want to try one. then we will see how xp uses a set of practices to build an effective software development team that produces quality software in a predictable and repeatable manner.
european experiences with software process improvement. assessment models used include spice (iso/iec tr 15504) [1] and software engineering institute's cmm1 [2] (one organisation also achieved iso9001 certification).
critical factors in establishing and maintaining trust in software outsourcing relationships. trust is considered one of the most important factors for successfully managing software outsourcing relationships. however, there is lack of research into understanding the factors that are considered important in establishing and maintaining trust between clients and vendors. the goal of this research is to gain an understanding of software outsourcing vendors' perceptions of the importance of factors that are critical to the establishment and maintenance of trust in software outsourcing projects in vietnam. we used a multiple case study design to guide our research and in-depth interviews to collect qualitative data from 12 vietnamese software development practitioners drawn from 8 companies that have been developing software for far eastern, european, and american clients. vendor companies identified that cultural understanding, creditability, capabilities, and personal visits are important factors in gaining the initial trust of a client, while cultural understanding, communication strategies, contract conformance, and timely delivery are vital factors in maintaining that trust.
a weakly constrained approach to software change coordination. the development of a software system ¿ of any reasonablesize ¿ from initial conception through ongoing maintenanceand evolution accrues significant coordination overheads.often the mechanisms used to manage change andcoordination detract from the time developers have to pursuethe principal goal of constructing the desired system.this is one of the motivators behind the emerging ýagileýmethodologies. by permitting people to work as independentlyas possible and yet be aware of each otherýs dependenciesand constraints, it is believed that these secondarycosts can be minimised. the position taken in theresearch summarised here is that better support can beprovided for this type of weakly constrained coordinationby enhancing the awareness, automated traceability, andconstraint checking capabilities of software configurationmanagement systems. current progress in the research andplans for future work are described.
an infrastructure for development of object-oriented, multi-level configuration management services. in an integrated development environment, the ability to manage the evolution of a software system in terms of logical abstractions, compositions, and their interrelations is crucial to successful software development. this paper presents a novel framework and infrastructure, molhado, upon which to build object-oriented software configuration management (scm) services in a scm-centered integrated development environment. key contributions of this paper include a product versioning model, an extensible, logical, and object-oriented system model, and a reusable product versioning scm infrastructure, that allow new types of objects to be implemented as extensions of the system model's basic entities. versions and configurations of objects are managed at different levels of abstraction and granularity. a new scm-centered editing environment or development environment for a specific development paradigm can be rapidly realized by re-using molhado's infrastructure and implementing new object types and their associated tools. this paper also demonstrates our approach in creating prototypes of scm-centered development environments for different paradigms.
practical approach to development of spi activities in a large organization: toshiba's spi history since 2000. for the effective promotion of software process improvement (spi) activities in a large-scale organization, it is necessary to establish an organizational structure and a deployment method for promotion and to develop training courses, support tools, and other materials. even if an organizational promotion system is established, the spi activities of each development department cannot be promoted effectively without spi community. to promote spi activities throughout the toshiba group, we organized a corporate software engineering process group in april 2000. we also have been focused to establish spi community, while promoting spi activities in each development department. the fundamental our operating policy of spi is "bottom-up". this paper discusses the problems encountered in the promotion of spi activities and presents solutions to the problems. the actual results obtained show that the framework and solutions developed by us can be used to effectively promote spi activities.
the vienna component framework enabling composition across component models. the vienna component framework (vcf) supports the interoperability and composability of components across different component models, a facility that is lacking in existing component models. the vcf presents a unified component model---implemented by a fa&ccedil;ade component---to the application programmer. the programmer may write new components by composing components from different component models, accessed through the vcf. the model supports common component features, namely, methods, properties, and events. to support a component model within the vcf, a plugin component is needed that provides access to the component model. the paper presents the vcf's design, implementation issues, and evaluation. performance measurements of vcf implementations of com, enterprise javabeans, corba distributed objects, and javabeans show that the overhead of accessing components through the vcf is negligible for distributed components.
the fujaba environment. however, a single collaboration diagram is usually not expressive enough to model complex operations performing several modifications at different parts of the overall object structure. such series of modifications need several collaboration diagrams to be modeled. in addition, there may be different situations where certain collaboration diagrams should be executed and others not. thus, we need additional control structures to control the execution of collaboration diagrams. in our approach we combine collaboration diagrams with statecharts and activity diagrams for this purpose. this means, instead of just pseudo code, any state or activity may contain a collaboration diagram modeling the do-action of this step.figure 1 illustrates the main concepts of fujaba. fujaba uses a combination of statecharts and collaboration diagrams to model the behavior of active classes. a combination of activity diagrams and collaboration diagrams models the bodies of complex methods. this integration of class diagrams and uml behavior diagrams enables fujaba to perform a lot of static analysis work facilitating the creation of a consistent overall specification. in addition, it turns these uml diagrams into a powerful visual programming language and allows to cover the generation of complete application code. during testing and maintenance the code of an application may be changed on the fly, e.g. to fix small problems. some application parts like the graphical user interface or complex mathematical computations may be developed with other tools. in cooperative (distributed) software development projects some developers may want to use fujaba, others may not. code of different developers may be merged by a version management tool. there might already exist a large application and one wants to use fujaba only for new parts. one may want to do a global search-and-replace to change some text phrases. one may temporarily violate syntactic code structures while she or he restructures some code. for all these reasons, fujaba aims to provide not just code generation but also the recovery of uml diagrams from java code. one may analyse (parts of) the application code, recover the corresponding uml diagram (parts), modify these diagram (parts), and generate new code (into the remaining application code). so far, this works reasonable for class diagrams and to some extend for the combination of activity and collaboration diagrams. for statecharts this is under development.the next chapters outline the (forward engineering) capabilities of fujaba with the help of an example session.