text stringlengths 17 3.36M | source stringlengths 3 333 | __index_level_0__ int64 0 518k |
|---|---|---|
The activity of design involves the decomposition of problems into subproblems and the development and evaluation of solutions. In many cases, solution development is not done from scratch. Designers often evoke and adapt solutions developed in the past. These solutions may come from an internal source, i.e. the memory of the designers, and/or from an external source. The goal of this paper is to analyse the characteristics of the cognitive mechanisms, the knowledge and the representations involved in the code reuse activity performed by experienced programmers. More generally, the focus is the control structure of the reuse activity. Data collected in an experiment in which programmers had to design programs are analyzed. Two code reuse situations are distinguished depending on whether or not the processes involved in reuse start before the elaboration of what acts as a source-solution. Our analysis highlights the use of reasoning from a schema and from an analog in the code reuse activity. | Reasoning from a schema and from an analog in software code reuse | 5,000 |
Refactoring is an established technique from the object-oriented (OO) programming community to restructure code: it aims at improving software readability, maintainability and extensibility. Although refactoring is not tied to the OO-paradigm in particular, its ideas have not been applied to Logic Programming until now. This paper applies the ideas of refactoring to Prolog programs. A catalogue is presented listing refactorings classified according to scope. Some of the refactorings have been adapted from the OO-paradigm, while others have been specifically designed for Prolog. The discrepancy between intended and operational semantics in Prolog is also addressed by some of the refactorings. In addition, ViPReSS, a semi-automatic refactoring browser, is discussed and the experience with applying ViPReSS to a large Prolog legacy system is reported. The main conclusion is that refactoring is both a viable technique in Prolog and a rather desirable one. | Improving Prolog programs: Refactoring for Prolog | 5,001 |
Pre-Requirement Specification traceability is the activity of capturing relations between requirements and their sources, in particular user needs. Requirements are formal technical specifications in the solution space; needs are natural language expressions codifying user expectations in the problem space. Current traceability techniques are challenged by the complexity gap that results from the disparity between the spaces, and thereby, often neglect traceability to and from requirements. We identify the existence of an intermediary region -- the transition space -- which structures the progression from needs to requirements. More specifically, our approach to developing change-tolerant systems, termed Capabilities Engineering, identifies highly cohesive, minimally coupled, optimized functional abstractions called Capabilities in the transition space. These Capabilities link the problem and solution spaces through directives (entities derived from user needs). Directives connect the problem and transition spaces; Capabilities link the transition and solution spaces. Furthermore, the process of Capabilities Engineering addresses specific traceability challenges. It supports the evolution of traces, provides semantic and structural information about dependencies, incorporates human factors, generates traceability relations with negligible overhead, and thereby, fosters pre-Requirement Specification traceability. | Pre-Requirement Specification Traceability: Bridging the Complexity Gap
through Capabilities | 5,002 |
Software reliability is an important quality attrib-ute, often evaluated as either a function of time or of system structures. The goal of this study is to have this metric cover both for component-based software, be-cause its reliability strongly depends on the quality of constituent components and their interactions. To achieve this, we apply a convolution modeling ap-proach, based on components' execution behavior, to integrate their individual reliability evolvement and simultaneously address failure fixes in the time do-main. Modeling at the component level can be more economical to accommodate software evolution, be-cause the reliability metric can be evaluated by reus-ing the quality measures of unaffected components and adapting only to the affected ones to save cost. The adaptation capability also supports the incremental software development processes that constantly add in new components over time. Experiments were con-ducted to discuss the usefulness of this approach. | Addressing Components' Evolvement and Execution Behavior to Measure
Component-Based Software Reliability | 5,003 |
In this paper we extend the classical portal (with static portlets) design with HTML DOM Web clipping on the client browser using dynamic JavaScript portlets: the portal server supplies the user/passwords for all services through https and the client browser retrieves web pages and cuts/selects/changes the desired parts using paths (XPath) in the Web page structure. This operation brings along a set of advantages: dynamic wrapping of existing legacy websites in the client browser, the reloading of only changed portlets instead of whole portal, low bandwidth on the server, the elimination of re-writing the URL links in the portal, and last but not least, a support for Java applets in portlets by putting the login cookies on the client browser. Our solution is compliant with JSR168 Portlet Specification allowing portability across all vendor platforms. | Portlet Wrappers using JavaScript | 5,004 |
Designing a web-application from a specification involves a series of well-planned and well executed steps leading to the final product. This often involves critical changes in design while testing the application, which itself is slow and cumbersome. Traditional approaches either fully automate the web-application development process, or let developers write everything from scratch. Our approach is based on a middle-ground, with precise control on the workflow and usage of a set of custom-made software tools to automate a significant part of code generation. | A Systematic Approach to Web-Application Development | 5,005 |
Many organizations aspire to adopt agile processes to take advantage of the numerous benefits that it offers to an organization. Those benefits include, but are not limited to, quicker return on investment, better software quality, and higher customer satisfaction. To date however, there is no structured process (at least in the public domain) that guides organizations in adopting agile practices. To address this problem we present the Agile Adoption Framework. The framework consists of two components: an agile measurement index, and a 4-Stage process, that together guide and assist the agile adoption efforts of organizations. More specifically, the agile measurement index is used to identify the agile potential of projects and organizations. The 4-Stage process, on the other hand, helps determine (a) whether or not organizations are ready for agile adoption, and (b) guided by their potential, what set of agile practices can and should be introduced. | A Disciplined Approach to Adopting Agile Practices: The Agile Adoption
Framework | 5,006 |
Engineering software systems is a multidisciplinary activity, whereby a number of artifacts must be created - and maintained - synchronously. In this paper we investigate whether production code and the accompanying tests co-evolve by exploring a project's versioning system, code coverage reports and size-metrics. Three open source case studies teach us that testing activities usually start later on during the lifetime and are more "phased", although we did not observe increasing testing activity before releases. Furthermore, we note large differences in the levels of test coverage given the proportion of test code. | On How Developers Test Open Source Software Systems | 5,007 |
Since perception tests are highly time-consuming, there is a need to automate as many operations as possible, such as stimulus generation, procedure control, perception testing, and data analysis. The computer-driven system we are presenting here meets these objectives. To achieve large flexibility, the tests are controlled by scripts. The system's core software resembles that of a lexical-syntactic analyzer, which reads and interprets script files sent to it. The execution sequence (trial) is modified in accordance with the commands and data received. This type of operation provides a great deal of flexibility and supports a wide variety of tests such as auditory-lexical decision making, phoneme monitoring, gating, phonetic categorization, word identification, voice quality, etc. To achieve good performance, we were careful about timing accuracy, which is the greatest problem in computerized perception tests. | PERCEVAL: a Computer-Driven System for Experimentation on Auditory and
Visual Perception | 5,008 |
We present the mathematical foundations of the contract-based model developed in the framework of the SPEEDS project. SPEEDS aims at developing methods and tools to support "speculative design", a design methodology in which distributed designers develop different aspects of the overall system, in a concurrent but controlled way. Our generic mathematical model of contract supports this style of development. This is achieved by focusing on behaviors, by supporting the notion of "rich component" where diverse (functional and non-functional) aspects of the system can be considered and combined, by representing rich components via their set of associated contracts, and by formalizing the whole process of component composition. | A Generic Model of Contracts for Embedded Systems | 5,009 |
Analytic execution architectures have been proposed by the same authors as a means to conceptualize the cooperation between heterogeneous collectives of components such as programs, threads, states and services. Interface groups have been proposed as a means to formalize interface information concerning analytic execution architectures. These concepts are adapted to organization architectures with a focus on financial transfers. Interface groups (and monoids) now provide a technique to combine interface elements into interfaces with the flexibility to distinguish between directions of flow dependent on entity naming. The main principle exploiting interface groups is that when composing a closed system of a collection of interacting components, the sum of their interfaces must vanish in the interface group modulo reflection. This certainly matters for financial transfer interfaces. As an example of this, we specify an interface group and within it some specific interfaces concerning the financial transfer architecture for a part of our local academic organization. Financial transfer interface groups arise as a special case of more general service architecture interfaces. | Interface groups and financial transfer architectures | 5,010 |
In this paper we propose a systematic strategy for migrating crosscutting concerns in existing object-oriented systems to aspect-based solutions. The proposed strategy consists of four steps: mining, exploration, documentation and refactoring of crosscutting concerns. We discuss in detail a new approach to aspect refactoring that is fully integrated with our strategy, and apply the whole strategy to an object-oriented system, namely the JHotDraw framework. The result of this migration is made available as an open-source project, which is the largest aspect refactoring available to date. We report on our experiences with conducting this case study and reflect on the success and challenges of the migration process, as well as on the feasibility of automatic aspect refactoring. | An Integrated Crosscutting Concern Migration Strategy and its
Application to JHotDraw | 5,011 |
Software is a communication system. The usual topic of communication is program behavior, as encoded by programs. Domain-specific libraries are codebooks, domain-specific languages are coding schemes, and so forth. To turn metaphor into method, we adapt toolsfrom information theory--the study of efficient communication--to probe the efficiency with which languages and libraries let us communicate programs. In previous work we developed an information-theoretic analysis of software reuse in problem domains. This new paper uses information theory to analyze tradeoffs in the design of components, generators, and metalanguages. We seek answers to two questions: (1) How can we judge whether a component is over- or under-generalized? Drawing on minimum description length principles, we propose that the best component yields the most succinct representation of the use cases. (2) If we view a programming language as an assemblage of metalanguages, each providing a complementary style of abstraction, how can these metalanguages aid or hinder us in efficiently describing software? We describe a complex triangle of interactions between the power of an abstraction mechanism, the amount of reuse it enables, and the cognitive difficulty of its use. | Parsimony Principles for Software Components and Metalanguages | 5,012 |
The design productivity gap requires more efficient design methods. Software systems have faced the same challenge and seem to have mastered it with the introduction of more abstract design methods. The UML has become the standard for software systems modeling and thus the foundation of new design methods. Although the UML is defined as a general purpose modeling language, its application to hardware and hardware/software codesign is very limited. In order to successfully apply the UML at these fields, it is essential to understand its capabilities and to map it to a new domain. | UML 2.0 - Overview and Perspectives in SoC Design | 5,013 |
Traditionally system design has been made from a black box/functionality only perspective which forces the developer to concentrate on how the functionality can be decomposed and recomposed into so called components. While this technique is well established and well known it does suffer fromsome drawbacks; namely that the systems produced can often be forced into certain, incompatible architectures, difficult to maintain or reuse and the code itself difficult to debug. Now that ideas such as the OMG's Model Based Architecture (MDA) or Model Based Engineering (MBE) and the ubiquitous modelling language UML are being used (allegedly) and desired we face a number of challenges to existing techniques. | Applying UML and MDA to Real Systems Design | 5,014 |
In this paper, we present a software compilation approach for microprocessor/FPGA platforms that partitions a software binary onto custom hardware implemented in the FPGA. Our approach imposes less restrictions on software tool flow than previous compiler approaches, allowing software designers to use any software language and compiler. Our approach uses a back-end partitioning tool that utilizes decompilation techniques to recover important high-level information, resulting in performance comparable to high-level compiler-based approaches. | A Decompilation Approach to Partitioning Software for
Microprocessor/FPGA Platforms | 5,015 |
Increasing reuse opportunities is a well-known problem for software designers as well as for hardware designers. Nonetheless, current software and hardware engineering practices have embraced different approaches to this problem. Software designs are usually modelled after a set of proven solutions to recurrent problems called design patterns. This approach differs from the component-based reuse usually found in hardware designs: design patterns do not specify unnecessary implementation details. Several authors have already proposed translating structural design patterns concepts to hardware design. In this paper we extend the discussion to behavioural design patterns. Specifically, we describe how the hardware version of the Iterator can be used to enhance model reuse. | Model Reuse through Hardware Design Patterns | 5,016 |
Complex real-time control system is a software dense and algorithms dense system, which needs modern software engineering techniques to design. UML is an object-oriented industrial standard modeling language, used more and more in real-time domain. This paper first analyses the advantages and problems of using UML for real-time control systems design. Then, it proposes an extension of UML-RT to support time-continuous subsystems modeling. So we can unify modeling of complex real-time control systems on UML-RT platform, from requirement analysis, model design, simulation, until generation code. | Unified Modeling of Complex Real-Time Control Systems | 5,017 |
This paper describes first results from the AutoMoDe (Automotive Model-Based Development) project. The overall goal of the project is to develop an integrated methodology for model-based development of automotive control software, based on problem-specific design notations with an explicit formal foundation. Based on the existing AutoFOCUS framework, a tool prototype is being developed in order to illustrate and validate the key elements of our approach. | AutoMoDe - Model-Based Development of Automotive Software | 5,018 |
Spreadsheet engineering adapts the lessons of software engineering to spreadsheets, providing eight principles as a framework for organizing spreadsheet programming recommendations. Spreadsheets raise issues inadequately addressed by software engineering. Spreadsheets are a powerful modeling language, allowing strategic rapid model change, and enabling exploratory modeling. Spreadsheets users learn slowly with experience because they focus on the problem domain not programming. The heterogeneity of spreadsheet users requires a taxonomy to guide recommendations. Deployment of best practices is difficult and merits research. | Spreadsheet Engineering: A Research Framework | 5,019 |
In agile software development, test code can considerably contribute to the overall source code size. Being a valuable asset both in terms of verification and documentation, the composition of a test suite needs to be well understood in order to identify opportunities as well as weaknesses for further evolution. In this paper, we argue that the visualization of structural characteristics is a viable means to support the exploration of test suites. Thanks to general agreement on a limited set of key test design principles, such visualizations are relatively easy to interpret. In particular, we present visualizations that support testers in (i) locating test cases; (ii) examining the relation between test code and production code; and (iii) studying the composition of and dependencies within test cases. By means of two case studies, we demonstrate how visual patterns help to identify key test suite characteristics. This approach forms the first step in assisting a developer to build up understanding about test suites beyond code reading. | Exploring the Composition of Unit Test Suites | 5,020 |
Control code is a concept that is closely related to a frequently occurring practitioner's view on what is a program: code that is capable of controlling the behaviour of some machine. We present a logical approach to explain issues concerning control codes that are independent of the details of the behaviours that are controlled. Using this approach, such issues can be explained at a very abstract level. We illustrate this among other things by means of an example about the production of a new compiler from an existing one. The approach is based on abstract machine models, called machine structures. We introduce a model of systems that provide execution environments for the executable codes of machine structures and use it to go into portability of control codes. | Machine structure oriented control code logic | 5,021 |
This paper presents the authors recommended practices for spreadsheet testing. Documented spreadsheet error rates are unacceptable in corporations today. Although improvements are needed throughout the systems development life cycle, credible improvement programs must include comprehensive testing. Several forms of testing are possible, but logic inspection is recommended for module testing. Logic inspection appears to be feasible for spreadsheet developers to do, and logic inspection appears to be safe and effective. | Recommended Practices for Spreadsheet Testing | 5,022 |
This paper investigates the usefulness of PSF in software engineering and reengineering. PSF is based on ACP (Algebra of Communicating Processes) and as some architectural description languages are based on process algebra, we investigate whether PSF can be used at the software architecture level, but we also use PSF at lower abstract levels. As a case study we reengineer the compiler from the Toolkit of PSF. | Software (Re-)Engineering with PSF | 5,023 |
This paper presents ongoing research on the application of PSF in the field of software engineering and reengineering. We build a new implementation for the simulator of the PSF Toolkit starting from the specification in PSF of the architecture of a simple simulator and extend it with features to obtain the architecture of a full simulator. We apply refining and constraining techniques on the specification of the architecture to obtain a specification low enough to build an implementation from. | Software (Re-)Engineering with PSF II: from architecture to
implementation | 5,024 |
We describe the design of an integrated development environment (IDE) for PSF. In the software engineering process we used process algebra in the form of PSF for the specification of the architecture of the IDE. This specification is refined to a PSF specification of the IDE system as a ToolBus application, by applying vertical and horizontal implementation techniques. We implemented the various tools as specified and connected them with a ToolBus script extracted from the system specification. | Software (Re-)Engineering with PSF III: an IDE for PSF | 5,025 |
The framework of promise theory offers an alternative way of understanding programming models, especially in distributed systems. We show that promise theory can express some familiar constructs and resolve some problems in program interface design, using fewer and simpler concepts than the Unified Modelling Language (UML). | Program Promises | 5,026 |
The data model of an application, the nature and format of data stored across executions, is typically a very rigid part of its early specification, even when prototyping, and changing it after code that relies on it was written can prove quite expensive and error-prone. Code and data in a running Lisp image can be dynamically modified. A MOP-based persistence library can bring this dynamicity to the data model. This enables to extend the easy prototyping way of development to the storage of data and helps avoiding interruptions of service. This article presents the conditions to do this portably and transparently. | Dynamic data models: an application of MOP-based persistence in Common
Lisp | 5,027 |
Several complexity metrics are described which are related to logic structure, data structure and size of spreadsheet models. They primarily concentrate on the dispersion of cell references and cell paths. Most metrics are newly defined, while some are adapted from traditional software engineering. Their purpose is the identification of cells which are liable to errors. In addition, they can be used to estimate the values of dependent process metrics, such as the development duration and effort, and especially to adjust the cell error rate in accordance with the contents of each individual cell, in order to accurately asses the reliability of a model. Finally, two conceptual constructs - the reference branching condition cell and the condition block - are discussed, aiming at improving the reliability, modifiability, auditability and comprehensibility of logical tests. | Complexity Metrics for Spreadsheet Models | 5,028 |
Our term "structure discovery" denotes the recovery of structure, such as the grouping of cells, that was intended by a spreadsheet's author but is not explicit in the spreadsheet. We are implementing structure discovery tools in the logic-programming language Prolog for our spreadsheet analysis program Model Master, by writing grammars for spreadsheet structures. The objective is an "intelligent structure monitor" to run beside Excel, allowing users to reconfigure spreadsheets to the representational needs of the task at hand. This could revolutionise spreadsheet "best practice". We also describe a formulation of spreadsheet reverse-engineering based on "arrows". | Spreadsheet Structure Discovery with Logic Programming | 5,029 |
This management summary provides an outline of a commercial spreadsheet review process. The aim of this process is to ensure remedial or enhancement work can safely be undertaken on a spreadsheet with a commercially acceptable level of risk of introducing new errors. | EuSpRIG 2006 Commercial Spreadsheet Review | 5,030 |
The objective of this paper is to develop a standardized methodology for software development in the very unique industry and culture of financial markets. The prototyping process we present allows the development team to deliver for review and comment intermediate-level models based upon clearly defined customer requirements. This spreadsheet development methodology is presented within a larger business context, that of trading system development, the subject of an upcoming book by the authors of this paper. | A Software Development Methodology for Research and Prototyping in
Financial Markets | 5,031 |
Spreadsheets often need changing in ways made tedious and risky by Excel. For example: simultaneously altering many tables' size, orientation, and position; inserting cross-tabulations; moving data between sheets; splitting and merging sheets. A safer, faster restructuring tool is, we claim, Excelsior. The result of a research project into reducing spreadsheet risk, Excelsior is the first ever tool for modularising spreadsheets; i.e. for building them from components which can be independently created, tested, debugged, and updated. It represents spreadsheets in a way that makes these components explicit, separates them from layout, and allows both components and layout to be changed without breaking dependent formulae. Here, we report experiments to test that this does indeed make such changes easier. In one, we automatically generated a cross-tabulation and added it to a spreadsheet. In the other, we generated new versions of a 10,000-cell housing-finance spreadsheet containing many interconnected 20*40 tables. We varied table sizes from 5*10 to 200*2,000; moved tables between sheets; and flipped table orientations. Each change generated a spreadsheet with different structure but identical outputs; each change took just a few minutes. | Rapid Spreadsheet Reshaping with Excelsior: multiple drastic changes to
content and layout are easy when you represent enough structure | 5,032 |
Companies that collaborate within the product development processes need to implement an effective management of their collaborative activities. Despite the implementation of a PLM system, the collaborative activities are not efficient as it might be expected. This paper presents an analysis of the problems related to the collaborative work using a PLM system. From this analysis, we propose an approach for improving collaborative processes within a PLM system, based on monitoring indicators. This approach leads to identify and therefore to mitigate the brakes of the collaborative work. | An approach to control collaborative processes in PLM systems | 5,033 |
At the 2003 EuSpRIG meeting, we presented a framework and software infrastructure to generate and analyse an audit trail for a spreadsheet file. This report describes the results of a pilot implementation of this software (now called TellTable; see www.telltable.com), along with developments in the server infrastructure and availability, extensions to other "Office Suite" files, integration of the audit tool into the server interface, and related developments, licensing and reports. We continue to seek collaborators and partners in what is primarily an open-source project with some shared-source components. | TellTable Spreadsheet Audit: from Technical Possibility to Operating
Prototype | 5,034 |
Excel lacks features for modular design. Had it such features, as do most programming languages, they would save time, avoid unneeded programming, make mistakes less likely, make code-control easier, help organisations adopt a uniform house style, and open business opportunities in buying and selling spreadsheet modules. I present Excelsior, a system for bringing these benefits to Excel. | Excelsior: Bringing the Benefits of Modularisation to Excel | 5,035 |
While developing an information system for the University of Bern, we were faced with two major issues: managing software changes and adapting Business Information Models. Software techniques well-suited to software development teams exist, yet the models obtained are often too complex for the business user. We will first highlight the conceptual problems encountered while designing the Business Information Model. We will then propose merging class diagrams and business process modeling to achieve a necessary transparency. We will finally present a modeling tool we developed which, using pilot case studies, helps to show some of the advantages of a dual model approach. | Merging Object and Process Diagrams for Business Information Modeling | 5,036 |
"Plat_Forms" is a competition in which top-class teams of three programmers compete to implement the same requirements for a web-based system within 30 hours, each team using a different technology platform (Java EE, .NET, PHP, Perl, Python, or Ruby on Rails). The results will provide new insights into the real (rather than purported) pros, cons, and emergent properties of each platform. The evaluation will analyze many aspects of each solution, both external (usability, functionality, reliability, performance, etc.) and internal (structure, understandability, flexibility, etc.). | Plat_Forms -- a contest: The web development platform comparison | 5,037 |
The paper presents two complementary strategies for identifying errors in spreadsheet programs. The strategies presented are grounded on the assumption that spreadsheets are software, albeit of a different nature than conventional procedural software. Correspondingly, strategies for identifying errors have to take into account the inherent properties of spreadsheets as much as they have to recognize that the conceptual models of 'spreadsheet programmers' differ from the conceptual models of conventional programmers. Nevertheless, nobody can and will write a spreadsheet, without having such a conceptual model in mind, be it of numeric nature or be it of geometrical nature focused on some layout. | Detecting Errors in Spreadsheets | 5,038 |
In this paper, we discuss the problem of the software engineering of a class of business spreadsheet models. A methodology for structured software development is proposed, which is based on structured analysis of data, represented as Jackson diagrams. It is shown that this analysis allows a straightforward modularisation, and that individual modules may be represented with indentation in the block-structured form of structured programs. The benefits of structured format are discussed, in terms of comprehensibility, ease of maintenance, and reduction in errors. The capability of the methodology to provide a modular overview in the model is described, and examples are given. The potential for a reverse-engineering tool, to transform existing spreadsheet models is discussed. | A Structured Methodology for Spreadsheet Modelling | 5,039 |
Students learning how to apply spreadsheets to accounting problems are not always well served by the built-in financial functions. Problems can arise because of differences between UK and US practice, through anomalies in the functions themselves, and because the promptings of Wizards' engender an attitude of filling in the blanks on the screen, and hoping for the best. Some examples of these problems are described, and suggestions are presented for ways of improving the situation. Principally, it is suggested that spreadsheet prompts and 'Help' screens should offer integrated guidance, covering some aspects of financial practice, as well as matters of spreadsheet technique. | Building Financial Accuracy into Spreadsheets | 5,040 |
This paper describes a framework for a systematic classification of spreadsheet errors. This classification or taxonomy of errors is aimed at facilitating analysis and comprehension of the different types of spreadsheet errors. The taxonomy is an outcome of an investigation of the widespread problem of spreadsheet errors and an analysis of specific types of these errors. This paper contains a description of the various elements and categories of the classification and is supported by appropriate examples. | Classification of Spreadsheet Errors | 5,041 |
Currently engineering efficient and successful event-driven applications based on the emerging Complex Event Processing (CEP) technology, is a laborious trial and error process. The proposed CEP design pattern approach should support CEP engineers in their design decisions to build robust and efficient CEP solutions with well understood tradeoffs and should enable an interdisciplinary and efficient communication process about successful CEP solutions in different application domains. | Design Patterns for Complex Event Processing | 5,042 |
In previous work we described how the process algebra based language PSF can be used in software engineering, using the ToolBus, a coordination architecture also based on process algebra, as implementation model. In this article we summarize that work and describe the software development process more formally by presenting the tools we use in this process in a CASE setting, leading to the PSF-ToolBus software engineering environment. We generalize the refine step in this environment towards a process algebra based software engineering workbench of which several instances can be combined to form an environment. | A Process Algebra Software Engineering Environment | 5,043 |
Testing is a vital part of software development, and spreadsheets are like any other software in this respect. This paper discusses the testing of spreadsheets in the light of one practitioner's experience. It considers the concept of software testing and how it differs from reviewing, and describes when it might take place. Different types of testing are described, and some techniques for performing them presented. Some of the commonly encountered problems are discussed. | When, why and how to test spreadsheets | 5,044 |
This paper proposes a theory of encapsulation, establishing a relationship between encapsulation and information hiding through the concept of potential structural complexity (P.S.C.), the maximum possible number of source code dependencies that can exist between program units in a software system. The P.S.C. of various, simple systems is examined in an attempt to demonstrate how P.S.C. changes as program units are encapsulated among different configurations of subsystems. | Encapsulation theory fundamentals | 5,045 |
This paper presents the design and the implementation of an interface software component between OLE for Process Control (OPC) formatted data and the Global Sensor Network (GSN) framework for management of data from sensors. This interface, named wrapper in the GSN context, communicates in Data Access mode with an OPC server and converts the received data to the internal GSN format, according to several temporal modes. This work is realized in the context of a Ph.D. Thesis about the control of distributed information fusion systems. The developed component allows the injection of OPC data, like measurements or industrial processes states information, into a distributed information fusion system deployed in a GSN framework. The component behaves as a client of the OPC server. Developed in Java and based on the Opensaca Utgard, it can be deployed on any computation node supporting a Java virtual machine. The experiments show the component conformity according to the Data Access 2.05a specification of the OPC standard and to the temporal modes. | Integrating OPC Data into GSN Infrastructures | 5,046 |
Building of tools--from simple prototypes to industrial-strength applications--is a pervasive activity in academic research. When proposing a new technique for software maintenance, effective tool support is typically required to demonstrate the feasibility and effectiveness of the approach. However, even though tool building is both pervasive and requiring significant time and effort, it is still pursued in an ad hoc manner. In this paper, we address these issues by proposing a dedicated development process for tool building that takes the unique characteristics of an academic research environment into account. We first identify process requirements based on a review of the literature and our extensive tool building experience in the domain of maintenance tools. We then outline a process framework based on work products that accommodates the requirements while providing needed flexibility for tailoring the process to account for specific tool building approaches and project constraints. The work products are concrete milestones of the process, tracking progress, rationalizing (design) decisions, and documenting the current state of the tool building project. Thus, the work products provide important input for strategic project decisions and rapid initiation of new team members. Leveraging a dedicated tool building process promises tools that are designed, build, and maintained in a more disciplined, predictable and efficient manner. | Towards a Process for Developing Maintenance Tools in Academia | 5,047 |
Nowadays, software has become a complex piece of work that may be beyond our control. Understanding how software evolves over time plays an important role in controlling software development processes. Recently, a few researchers found the quantitative evidence of structural duplication in software systems or web applications, which is similar to the evolutionary trend found in biological systems. To investigate the principles or rules of software evolution, we introduce the relevant theories and methods of complex networks into structural evolution and change of software systems. According to the results of our experiment on network motifs, we find that the stability of a motif shows positive correlation with its abundance and a motif with high Z score tends to have stable structure. These findings imply that the evolution of software systems is based on functional cloning as well as structural duplication and tends to be structurally stable. So, the work presented in this paper will be useful for the analysis of structural changes of software systems in reverse engineering. | Network Motifs in Object-Oriented Software Systems | 5,048 |
Domain specific software architecture aims at software reuse through construction of domain architecture reference model. The constructed reference model presents a set of individual components and their interaction points. When starting on a new large software project, the design engineer starts with pre-constructed model, which can be easily browsed and picks up opportunities of use in the new solution design. This report discusses application of domain reference design methods by deriving domain specific reference architecture for a product ordering system in a design center. The product in this case is instock and special order blinds from different manufacturers in a large supply store. The development of mature domain specific reference software architecture for this domain is not the objective of this report. However, this report would like to capture the method used in one such process and that is the primary concern of this report. This report lists subjective details of such a process applied to the domain of ordering custom and instock blinds from a large home construction and goods supply store. This report also describes the detailed process of derivation of knowledge models, unified knowledge models and the reference architecture for this domain. However, this domain model is only partially complete which may not be used for any real applications. This report is a result of a course project undertaken while studying this methodology. | Domain Specific Software Architecture for Design Center Automation | 5,049 |
ADAPT is a tool that aims at easing the task of evaluating dependability measures in the context of modern model driven engineering processes based on AADL (Architecture Analysis and Design Language). Hence, its input is an AADL architectural model annotated with dependability-related information. Its output is a dependability evaluation model in the form of a Generalized Stochastic Petri Net (GSPN). The latter can be processed by existing dependability evaluation tools, to compute quantitative measures such as reliability, availability, etc.. ADAPT interfaces OSATE (the Open Source AADL Tool Environment) on the AADL side and SURF-2, on the dependability evaluation side. In addition, ADAPT provides the GSPN in XML/XMI format, which represents a gateway to other dependability evaluation tools, as the processing techniques for XML files allow it to be easily converted to a tool-specific GSPN. | The ADAPT Tool: From AADL Architectural Models to Stochastic Petri Nets
through Model Transformation | 5,050 |
Performing dependability evaluation along with other analyses at architectural level allows both making architectural tradeoffs and predicting the effects of architectural decisions on the dependability of an application. This paper gives guidelines for building architectural dependability models for software systems using the AADL (Architecture Analysis and Design Language). It presents reusable modeling patterns for fault-tolerant applications and shows how the presented patterns can be used in the context of a subsystem of a real-life application. | Software dependability modeling using an industry-standard architecture
description language | 5,051 |
As the digital world enters further into everyday life, questions are raised about the increasing challenges brought by the interaction of real-time software with physical devices. Many accidents and incidents encountered in areas as diverse as medical systems, transportation systems or weapon systems are ultimately attributed to "software failures". Since real-time software that interacts with physical systems might as well be called control software, the long litany of accidents due to real-time software failures might be taken as an equally long list of opportunities for control systems engineering. In this paper, we are interested only in run-time errors in those pieces of software that are a direct implementation of control system specifications: For well-defined and well-understood control architectures such as those present in standard textbooks on digital control systems, the current state of theoretical computer science is well-equipped enough to address and analyze control algorithms. It appears that a central element to these analyses is Lyapunov stability theory, which translate into invariant theory in computer implementations. | Control software analysis, Part I Open-loop properties | 5,052 |
The main problems of Software Engineering appear as a result of incompatibilities. For example, the quality of organization of the production process depends on correspondence with existent resources and on a common understanding of project goals by all team members. Software design is another example. Its successfulness rides on the architecture's conformity with a project's concepts. This is a point of great nicety. All elements should create a single space of interaction. And if the laws of such a space are imperfect, missequencing comes and the concept of a software system fails. We must do our best for this not to happen. To that end, having a subtle perception of systems structures is essential. Such knowledge can be based only on a fresh approach to the logical law. | Software Engineering & Systems Design Nature | 5,053 |
Les entreprises qui collaborent dans un processus de d\'eveloppement de produit ont besoin de mettre en oeuvre une gestion efficace des activit\'es collaborative. Malgr\'e la mise en place d'un PLM, les activit\'es collaborative sont loin d'\^etre aussi efficace que l'on pourrait s'y attendre. Cet article propose une analyse des probl\'ematiques de la collaboration avec un syst\`eme PLM. A partir de ces analyses, nous proposons la mise en place d'indicateurs et d'actions sur les processus visant \`a identifier puis att\'enuer les freins dans le travail collaboratif. ----- Companies that collaborate within the product development processes need to implement an effective management of their collaborative activities. Despite the implementation of a PLM system, the collaborative activities are not efficient as it might be expected. This paper presents an analysis of the problems related to the collaborative work using a PLM system, identified through a survey. From this analysis, we propose an approach for improving collaborative processes within a PLM system, based on monitoring indicators. This approach leads to identify and therefore to mitigate the brakes of the collaborative work. | Pilotage des processus collaboratifs dans les systèmes PLM. Quels
indicateurs pour quelle évaluation des performances ? | 5,054 |
This paper aims at analyzing the problems related to collaborative work using a PLM system. This research is mainly focused on the organisational aspects of SMEs involved in networks composed of large companies, subcontractors and other industrial partners. From this analysis, we propose the deployment of an approach based on an observation process of tracks generated by PLM system. The specific contributions are of two fold. First is to identify the brake points of collaborative work. The second, thanks to the exploitation of generated tracks, it allows reducing risks by reacting in real time to the incidents or dysfunctions that may occur. The overall system architecture based on services technology and supporting the proposed approach is described, as well as associated prototype developed using an industrial PLM system. | Collaborative process control: Observation of tracks generated by PLM
system | 5,055 |
This paper shows how maximum possible configuration efficiency of an indefinitely large software system is constrained by chosing a fixed upper limit to the number of program units per subsystem. It is then shown how the configuration efficiency of an indefinitely large software system depends on the ratio of the total number of informaiton hiding violational software units divided by the total number of program units. | Encapsulation theory: the configuration efficiency limit | 5,056 |
For Paradigm models, evolution is just-in-time specified coordination conducted by a special reusable component McPal. Evolution can be treated consistently and on-the-fly through Paradigm's constraint orchestration, also for originally unforeseen evolution. UML-like diagrams visually supplement such migration, as is illustrated for the case of a critical section solution evolving into a pipeline architecture. | Dynamic System Adaptation by Constraint Orchestration | 5,057 |
Mancoosi (Managing the Complexity of the Open Source Infrastructure) is an ongoing research project funded by the European Union for addressing some of the challenges related to the "upgrade problem" of interdependent software components of which Debian packages are prototypical examples. Mancoosi is the natural continuation of the EDOS project which has already contributed tools for distribution-wide quality assurance in Debian and other GNU/Linux distributions. The consortium behind the project consists of several European public and private research institutions as well as some commercial GNU/Linux distributions from Europe and South America. Debian is represented by a small group of Debian Developers who are working in the ranks of the involved universities to drive and integrate back achievements into Debian. This paper presents relevant results from EDOS in dependency management and gives an overview of the Mancoosi project and its objectives, with a particular focus on the prospective benefits for Debian. | Solving package dependencies: from EDOS to Mancoosi | 5,058 |
This document contains several related specifications, together they describe the document formats related to the solver competition which will be organized by Mancoosi. In particular, this document describes: - DUDF (Distribution Upgradeability Description Format), the document format to be used to submit upgrade problem instances from user machines to a (distribution-specific) database of upgrade problems; - CUDF (Common Upgradeability Description Format), the document format used to encode upgrade problems, abstracting over distribution-specific details. Solvers taking part in the competition will be fed with input in CUDF format. | Description of the CUDF Format | 5,059 |
In their seminal paper in the ACM Transactions on Software Engineering and Methodology, Zave and Jackson established a core ontology for Requirements Engineering (RE) and used it to formulate the "requirements problem", thereby defining what it means to successfully complete RE. Given that stakeholders of the system-to-be communicate the information needed to perform RE, we show that Zave and Jackson's ontology is incomplete. It does not cover all types of basic concerns that the stakeholders communicate. These include beliefs, desires, intentions, and attitudes. In response, we propose a core ontology that covers these concerns and is grounded in sound conceptual foundations resting on a foundational ontology. The new core ontology for RE leads to a new formulation of the requirements problem that extends Zave and Jackson's formulation. We thereby establish new standards for what minimum information should be represented in RE languages and new criteria for determining whether RE has been successfully completed. | Revisiting the Core Ontology and Problem in Requirements Engineering | 5,060 |
In this paper, we propose a refinement-based adaptation approach for the architecture of distributed group communication support applications. Unlike most of previous works, our approach reaches implementable, context-aware and dynamically adaptable architectures. To model the context, we manage simultaneously four parameters that influence Qos provided by the application. These parameters are: the available bandwidth, the exchanged data communication priority, the energy level and the available memory for processing. These parameters make it possible to refine the choice between the various architectural configurations when passing from a given abstraction level to the lower level which implements it. Our approach allows the importance degree associated with each parameter to be adapted dynamically. To implement adaptation, we switch between the various configurations of the same level, and we modify the state of the entities of a given configuration when necessary. We adopt the direct and mediated Producer- Consumer architectural styles and graphs for architecture modelling. In order to validate our approach we elaborate a simulation model. | Context-aware adaptation for group communication support applications
with dynamic architecture | 5,061 |
The recent apparition of mobile wireless sensor aware to their physical environment and able to process information must allow proposing applications able to take into account their physical context and to react according to the changes of the environment. It suppose to design applications integrating both software and hardware components able to communicate. Applications must use context information from components to measure the quality of the proposed services in order to adapt them in real time. This work is interested in the integration of sensors in distributed applications. It present a service oriented software architecture allowing to manage and to reconfigure applications in heterogeneous environment where entities of different nature collaborate: software components and wireless sensors. | Architecture Logicielles pour des Applications hétérogènes,
distribuées et reconfigurables | 5,062 |
This paper describes how the maximum potential number of edges of an encapsulated graph varies as the graph is transformed, that is, as nodes are created and modified. The equations governing these changes of maximum potential number of edges caused by the transformations are derived and briefly analysed. | Encapsulation theory: the transformation equations of absolute
information hiding | 5,063 |
This article presents a Verification and Validation approach which is used here in order to complete the classical tool box the industrial user may utilize in Enterprise Modeling and Integration domain. This approach, which has been defined independently from any application domain is based on several formal concepts and tools presented in this paper. These concepts are property concepts, property reference matrix, properties graphs, enterprise modeling domain ontology, conceptual graphs and formal reasoning mechanisms. | Enterprise model verification and validation: an approach | 5,064 |
A requirements engineering artifact is valid relative to the stakeholders of the system-to-be if they agree on the content of that artifact. Checking relative validity involves a discussion between the stakeholders and the requirements engineer. This paper proposes (i) a language for the representation of information exchanged in a discussion about the relative validity of an artifact; (ii) the acceptability condition, which, when it verifies in a discussion captured in the proposed language, signals that the relative validity holds for the discussed artifact and for the participants in the discussion; and (iii) reasoning procedures to automatically check the acceptability condition in a discussions captured by the proposed language. | Towards a Theory of Requirements Elicitation: Acceptability Condition
for the Relative Validity of Requirements | 5,065 |
XML is based on two essential aspects: the modelization of data in a tree like structure and the separation between the information itself and the way it is displayed. XML structures are easily serializable. The separation between an abstract representation and one or several views on it allows the elaboration of specialized interfaces to visualize or modify data. A lot of developments were made to interact with XML data but the use of these applications over the Internet is just starting. This paper presents a prototype of a distributed editing environment over the Internet. The key point of our system is the way user interactions are handled. Selections and modifications made by a user are not directly reflected on the concrete view, they are serialized in XML and transmitted to a server which applies them to the document and broadcasts updates to the views. This organization has several advantages. XML documents coding selection and modification operations are usually smaller than the edited document and can be directly processed with a transformation engine which can adapt them to different representations. In addition, several selections or modifications can be combined into an unique XML document. This allows one to update multiple views with different frequencies and fits the requirement of an asynchronous communication mode like HTTP. | A distributed editing environment for XML documents | 5,066 |
This paper proposes an introduction to one of the newest modelling methods, an executable model based on workflows. We present the terminology for some basic workflow patterns, as described in the Workflow Management Coalition Terminology and Glossary. | Workflow Patterns in Process Modeling | 5,067 |
The paper presents a description of some point of view of different authors related to the failures and exceptions that appear in workflows, as a direct consequence of unavailability of resources involved in the workflow. Each of these interpretations is typical for a certain situation, depending on the authors' interpretation of failures and exceptions in workflows modeling real dynamical systems. | Considerations on Resource Usage in Exceptions and Failures in Workflows | 5,068 |
The globalization of the software market leads to crucial problems for software companies. More competition between software companies arises and leads to the force on companies to develop ever newer software products in ever shortened time interval. Therefor the time to market for software systems is shortened and obviously the product life cycle is shortened too[...]The approach introduced here presents the novel technique together with a supportive environment that enables developers to cope with the adaptability of black-box software components. A supported environment will be designed that checks the compatibility of black-box software components with the assistance of their specifications. | Adaptation of Black-Box Software Components | 5,069 |
Dynamically Adaptive Systems (DAS) are systems that modify their behavior and structure in response to changes in their surrounding environment. Critical mission systems increasingly incorporate adaptation and response to the environment; examples include disaster relief and space exploration systems. These systems can be decomposed in two parts: the adaptation policy that specifies how the system must react according to the environmental changes and the set of possible variants to reconfigure the system. A major challenge for testing these systems is the combinatorial explosions of variants and envi-ronment conditions to which the system must react. In this paper we focus on testing the adaption policy and propose a strategy for the selection of envi-ronmental variations that can reveal faults in the policy. Artificial Shaking Table Testing (ASTT) is a strategy inspired by shaking table testing (STT), a technique widely used in civil engineering to evaluate building's structural re-sistance to seismic events. ASTT makes use of artificial earthquakes that simu-late violent changes in the environmental conditions and stresses the system adaptation capability. We model the generation of artificial earthquakes as a search problem in which the goal is to optimize different types of envi-ronmental variations. | Artificial table testing dynamically adaptive systems | 5,070 |
The semantic technologies pose new challenge for the way in which we built and operate systems. They are tools used to represent significances, associations, theories, separated from data and code. Their goal is to create, to discover, to represent, to organize, to process, to manage, to ratiocinate, to represent, to share and use the significances and knowledge to fulfill the business, personal or social goals. | Delving into Transition to the Semantic Web | 5,071 |
FLASH is a publicly available high performance application code which has evolved into a modular, extensible software system from a collection of unconnected legacy codes. FLASH has been successful because its capabilities have been driven by the needs of scientific applications, without compromising maintainability, performance, and usability. In its newest incarnation, FLASH3 consists of inter-operable modules that can be combined to generate different applications. The FLASH architecture allows arbitrarily many alternative implementations of its components to co-exist and interchange with each other, resulting in greater flexibility. Further, a simple and elegant mechanism exists for customization of code functionality without the need to modify the core implementation of the source. A built-in unit test framework providing verifiability, combined with a rigorous software maintenance process, allow the code to operate simultaneously in the dual mode of production and development. In this paper we describe the FLASH3 architecture, with emphasis on solutions to the more challenging conflicts arising from solver complexity, portable performance requirements, and legacy codes. We also include results from user surveys conducted in 2005 and 2007, which highlight the success of the code. | Extensible Component Based Architecture for FLASH, A Massively Parallel,
Multiphysics Simulation Code | 5,072 |
Analysis of a system constitutes the most important aspect of the systems development life cycle.But it is also the most confusing and time consuming of all the stages.The critical question always remains: How much and till when to analyse? Ed Yourdon has called this phenomenon as Analysis Paralysis. In this paper, I suggest a model which can actually help in arriving at a satisfactory answer to this problem. | Analysis Paralysis: when to stop? | 5,073 |
The current INFRAWEBS European research project aims at developing ICT framework enabling software and service providers to generate and establish open and extensible development platforms for Web Service applications. One of the concrete project objectives is developing a full-life-cycle software toolset for creating and maintaining Semantic Web Services (SWSs) supporting specific applications based on Web Service Modelling Ontology (WSMO) framework. According to WSMO, functional and behavioural descriptions of a SWS may be represented by means of complex logical expressions (axioms). The paper describes a specialized user-friendly tool for constructing and editing such axioms - INFRAWEBS Axiom Editor. After discussing the main design principles of the Editor, its functional architecture is briefly presented. The tool is implemented in Eclipse Graphical Environment Framework and Eclipse Rich Client Platform. | INFRAWEBS axiom editor - a graphical ontology-driven tool for creating
complex logical expressions | 5,074 |
In software development process we come across various modules. Which raise the idea of priority of the different modules of a software so that important modules are tested on preference. This approach is desirable because it is not possible to test each module regressively due to time and cost constraints. This paper discuss on some parameters, required to prioritize several modules of a software and provides measure of optimal time and cost for testing based on non homogeneous Poisson process. | Non Homogeneous Poisson Process Model based Optimal Modular Software
Testing using Fault Tolerance | 5,075 |
BPMN represents an industrial standard created to offer a common and user friendly notation to all the participants to a business process. The present paper aims to briefly present the main features of this notation as well as an interpretation of some of the main patterns characterizing a business process modeled by the working fluxes. | Business Process Modeling Notation - An Overview | 5,076 |
VISP (Virtual Internet Service Provider) is an IST-STREP project, which is conducting research in the field of these new technologies, targeted to telecom/ISP companies. One of the first tasks of the VISP project is to identify the most appropriate technologies in order to construct the VISP platform. This paper presents the most significant results in the field of choreography and orchestration, two key domains that must accompany process modeling in the construction of a workflow environment. | Tailored business solutions by workflow technologies | 5,077 |
The unconventional technologies, currently applied at a certain category of materials, difficult to be processed through usual techniques, have undergone during the last 60 years all the stages, since their discovery to their use on a large scale. They are based on elementary mechanisms which run the processing through classic methods, yet, they use in addition the interconnections of these methods. This leads to a plus in performance by increasing the outcomes precision, reducing the processing time, increasing the quality of the finite product, etc. This performance can be much increased by using the computer and a software product in assisting the human operator in the processing by an unconventional method such as; the electric or electro-chemical erosion, the complex electric-electro-chemical erosion, the processing by a laser fascicle and so on. The present work presents such an application based on a data base combining the previous experimental results, which proposes a method of optimization of the outcomes. | Computer Aided Optimization of the Unconventional Processing | 5,078 |
Control systems are sets of interconnected hardware and software components which regulate the behaviour of processes. The software of modern control systems rises for some years by requirements regarding the flexibility and functionality. Thus the force of innovation grows on enterprises, since ever newer products in ever shorter time intervals must be made available. Associated hereby is the crucial shortening of the product life cycle, whose effects show up in reduced care of the software and the spares inventory. The aim, the concept presented here and developed in a modeling environment, is proved and ensures a minimum functionality of software components. Replacing software components of a control system verified for functionality by a framework at run-time and if necessary the software conditions will become adapted. Quintessential point of this implementation is the usage of an abstract syntax tree. Within its hierarchical structure meta information is attached to nodes and processed by the framework. With the development of the concept for semantic proving of software components the lifetime of software-based products is increased. | Semantic Linkage of Control Systems | 5,079 |
Computing systems are becoming more and more complex and assuming more and more responsibilities in all sectors of human activity. Applications do not run locally on a single computer any more. A lot of today's applications are built as distributed system; with services on different computers communicating with each other. Distributed systems arise everywhere. The Internet is one of the best-known distributed systems and used by nearly everyone today. It is obvious that we are more and more dependent on computer services. Many people expect to be able to buy things like clothing or electronic equipment even at night on the Internet. Computers are expected to be operational and available 7 days a week, 24 hours a day. Downtime, even for maintenance, is no longer acceptable. | Failover of Software Services with State Replication | 5,080 |
The idea of the Neurath Basic Model View Controller (NBMVC) appeared during the discussion of the design of domain-specific modeling tools based on the Neurath Modeling Language [Yer06]. The NBMVC is the core of the modeling process within the modeling environment. It reduces complexity out of the design process by providing domain-specific interfaces between the developer and the model. These interfaces help to organize and manipulate the model. The organization includes, for example, a layer with visual components to drop them in and filter them out. The control routines includes, for example, model transformations. | Architecture of the Neurath Basic Model View Controller | 5,081 |
Through its projects, the ?Atelier Inter-\'etablissements de Productique Lorrain? (AIPL), as the owner and contractor of rank 1, is committed to provide his customers (teachers, training courses, students etc...) credible teaching materials at the scale of a real industrial flexible production of goods and services. In this changing context, its managerial team has chosen to suppress the CIM concept, which proposes an integrated enterprise, to steering distributed system information (SI), heterogeneous, autonomous and scalable depending on the ephemeral cooperation between industrial partners who now exchanges information and material flows. These aspects are studied in research on CRAN (Centre de Recherche en Automatique de Nancy ? Research Centre for Automatic Control) as part of a thesis based on the recursive aspect of systems and their models and their multi-scale aspects and multi-views, in a Model-Based-System-Engineering (MBSE) methodology proposal of an System-Engineering (SE) focused on the product. To validate this research, a MBSE has been implemented on a case study to AIPL: the "eLearning in eProduction? project. | Ingénierie système d'un système d'information d'entreprise
centré sur le produit basée sur un cadre de modélisation
multi-échelles : application à un cas d'étude de l'AIP lorrain | 5,082 |
Component-based systems often describe context requirements in terms of explicit inter-component dependencies. Studying large instances of such systems?such as free and open source software (FOSS) distributions?in terms of declared dependencies between packages is appealing. It is however also misleading when the language to express dependencies is as expressive as boolean formulae, which is often the case. In such settings, a more appropriate notion of component dependency exists: strong dependency. This paper introduces such notion as a first step towards modeling semantic, rather then syntactic, inter-component relationships. Furthermore, a notion of component sensitivity is derived from strong dependencies, with ap- plications to quality assurance and to the evaluation of upgrade risks. An empirical study of strong dependencies and sensitivity is presented, in the context of one of the largest, freely available, component-based system. | Strong Dependencies between Software Components | 5,083 |
Improvement of industrial performance such as cost, lead-time, adaptability, variety and traceability is the major finality of companies. At this need corresponds the necessity to collaborate and to strengthen their coordination mechanisms. Information exchange becomes then a strategic question: what is the nature of the information that can be shared with customers and suppliers? Which impact on the performance of a company is expectable? What about the performance of the whole supply chain? It is essential for a company to identify the information whose exchange contributes to its performance and to control its information flows. This study aims to release from the literature the main tendencies of collaboration practices and information exchanges leading to the performance and to propose a model of hypothesis gathering these practices. | Modélisation des facteurs influençant la performance de la
chaîne logistique | 5,084 |
Reuse-based software development provides an opportunity for better quality and increased productivity in the software products. One of the most critical aspects of the quality of a software system is its performance. The systematic application of software performance engineering techniques throughout the development process can help to identify design alternatives that preserve desirable qualities such as extensibility and reusability while meeting performance objectives. In the present scenario, most of the performance failures are due to a lack of consideration of performance issues early in the development process, especially in the design phase. These performance failures results in damaged customer relations, lost productivity for users, cost overruns due to tuning or redesign, and missed market windows. In this paper, we propose UML based Performance Models for design assessment in a reuse based software development scenario. | Derivation of UML Based Performance Models for Design Assessment in a
Reuse Based Software Development Approach | 5,085 |
Actual organization are structured and act with the help of their information systems. In spite of considerable progresses made by computer technology, we note that actors are very often critical on their information systems. Difficulties to product specifications enough detailed for functional profile and interpretable by information system expert is one of reason of this gap between hopes and reality. Our proposition wants to get over this obstacle by organizing user requirements in a common language of operational profile and technical expert.-- Les organisations actuelles se structurent et agissent en s'appuyant sur leurs syst\`emes d'information. Malgr\'e les progr\`es consid\'erables r\'ealis\'es par la technologie informatique, on constate que les acteurs restent tr\`es souvent critiques par rapport \`a leur syst\`emes d'information. Une des causes de cet \'ecart entre les espoirs et la r\'ealit\'e trouve sa source dans la difficult\'e \`a produire un cahier des charges suffisamment d\'etaill\'e pour les op\'erationnels et interpr\'etable par les sp\'ecialistes des syst\`emes d'information. Notre proposition vise \`a surmonter cet obstacle en organisant l'expression des besoins dans un langage commun aux op\'erationnels et aux experts techniques. Pour cela, le langage propos\'e pour exprimer les besoins est bas\'e sur la notion de but. L'ing\'enierie dirig\'ee par les mod\`eles est pr\'esente \`a toute les \'etapes, c'est-\`a-dire au moment de la capture et de l'interpr\'etation. | Améliorer les performances de l'industrie logicielle par une meilleure
compréhension des besoins | 5,086 |
Today, it is important for software companies to build software systems in a short time-interval, to reduce costs and to have a good market position. Therefore well organized and systematic development approaches are required. Reusing software components, which are well tested, can be a good solution to develop software applications in effective manner. The reuse of software components is less expensive and less time consuming than a development from scratch. But it is dangerous to think that software components can be match together without any problems. Software components itself are well tested, of course, but even if they composed together problems occur. Most problems are based on interaction respectively communication. Avoiding such errors a framework has to be developed for analysing software components. That framework determines the compatibility of corresponding software components.The promising approach discussed here, presents a novel technique for analysing software components by applying an Abstract Syntax Language Tree (ASLT). A supportive environment will be designed that checks the compatibility of black-box software components. This article is concerned to the question how can be coupled software components verified by using an analyzer framework and determines the usage of the ASLT. Black-box Software Components and Abstract Syntax Language Tree are the basis for developing the proposed framework and are discussed here to provide the background knowledge. The practical implementation of this framework is discussed and shows the result by using a test environment. | Analyser Framework to verify Software Component | 5,087 |
Requirements engineering is known to be a key factor for the success of software projects. Inside this discipline, goal-oriented requirements engineering approaches have shown specially suitable to deal with projects where it is necessary to capture the alignment between system requirements and stakeholders' needs, as is the case of data-warehousing projects. However, the mere alignment of data-warehouse system requirements with business goals is not enough to assure better data-warehousing products; measures and techniques are also needed to assure the data-warehouse quality. In this paper, we provide a modelling framework for data-warehouse quality measurement (i*DWQM). This framework, conceived as an i* extension, provides support for the definition of data-warehouse requirements analysis models that include quantifiable quality scenarios, defined in terms of well-formed measures. This extension has been defined by means of a UML profiling architecture. The resulting framework has been implemented in the Eclipse development platform. | Goal-oriented Data Warehouse Quality Measurement | 5,088 |
This work is an introduction to the author's contributions to the SOC area, resulting from his PhD research activity. It focuses on the problem of automatically composing a desired service, given a set of available ones and a target specification. As for description, services are represented as finite-state transition systems, so to provide an abstract account of their behavior, seen as the set of possible conversations with external clients. In addition, the presence of a finite shared memory is considered, that services can interact with and which provides a basic form of communication. Rather than describing technical details, we offer an informal overview of the whole work, and refer the reader to the original papers, referenced throughout this work, for all details. | An Introduction to Simulation-Based Techniques for Automated Service
Composition | 5,089 |
Service Oriented Architectures (SOAs) are component-based architectures, characterized by reusability, modularization and composition, usually offered by HTTP (web services) and often equipped with a Quality of Services (QoS) measure. In order to guarantee the fairness property to each client requesting a service, we propose a fair version of the (Soft) Concurrent Constraint language to deal with the negotiation phases of the Service Level Agreement (SLA) protocol. | Fairness as a QoS Measure for Web Services | 5,090 |
Location- and context-aware services are emerging technologies in mobile and desktop environments, however, most of them are difficult to use and do not seem to be beneficial enough. Our research focuses on designing and creating a service-oriented framework that helps location- and context-aware, client-service type application development and use. Location information is combined with other contexts such as the users' history, preferences and disabilities. The framework also handles the spatial model of the environment (e.g. map of a room or a building) as a context. The framework is built on a semantic backend where the ontologies are represented using the OWL description language. The use of ontologies enables the framework to run inference tasks and to easily adapt to new context types. The framework contains a compatibility layer for positioning devices, which hides the technical differences of positioning technologies and enables the combination of location data of various sources. | Service-oriented Context-aware Framework | 5,091 |
The number of web services increased vastly in the last years. Various providers offer web services with the same functionality, so for web service consumers it is getting more complicated to select the web service, which best fits their requirements. That is why a lot of the research efforts point to discover semantic means for describing web services taking into account not only functional characteristics of services, but also the quality of service (QoS) properties such as availability, reliability, response time, trust, etc. This motivated us to research current approaches presenting complete solutions for QoS enabled web service description, publication and discovery. In this paper we present comparative analysis of these approaches according to their common principals. Based on such analysis we extract the essential aspects from them and propose a pattern for the development of QoS-aware service-oriented architectures. | Towards a Unifying View of QoS-Enhanced Web Service Description and
Discovery Approaches | 5,092 |
Process Management Systems (PMSs) are currently more and more used as a supporting tool for cooperative processes in pervasive and highly dynamic situations, such as emergency situations, pervasive healthcare or domotics/home automation. But in all such situations, designed processes can be easily invalidated since the execution environment may change continuously due to frequent unforeseeable events. This paper aims at illustrating the theoretical framework and the concrete implementation of SmartPM, a PMS that features a set of sound and complete techniques to automatically cope with unplanned exceptions. PMS SmartPM is based on a general framework which adopts the Situation Calculus and Indigolog. | Adaptive Process Management in Highly Dynamic and Pervasive Scenarios | 5,093 |
Service-Oriented Computing (SOC) is an emerging new paradigm for distributed and object-oriented computing by allowing autonomous, platform-independent computational entities (called services) to be built (described, discovered, composed, orchestrated) within and across organizational boundaries. Like no other computing paradigm before, SOC is destined to exert a lasting influence on the business domain, among others (e-commerce, e-government, e-business, e-learning, e-health, etc.). The Young Researchers workshop series on Service-Oriented Computing is meant to be a platform for junior researchers from industry and academics alike. Its core objectives are to exchange information regarding advancements in the state of the art and practice of SOC, as well as to identify emerging research topics and the future trends in this domain. Following the success of the previous three workshops, the 4th European Young Researchers Workshop on Service-Oriented Computing (YR-SOC 2009) introduced two novelties: it was organised outside of the UK and it saw the introduction of a number of tutorials, thus making the workshop a 3-day event. YR-SOC 2009 took place at the CNR Institute of Information Science and Technologies in Pisa, Italy, and was organised by Maurice ter Beek, Barry Norton, Stephan Reiff-Marganiec and Monika Solanki. The contributions in this volume cover aspects such as automated service composition, context-aware SOC, service-oriented programming, QoS-aware SOC, service-oriented architectures, SOC modelling and analysis, process management, web services, ontologies and the semantic web. | Proceedings Fourth European Young Researchers Workshop on Service
Oriented Computing | 5,094 |
Most of the research related to Non Functional Requirements (NFRs) have presented NFRs frameworks by integrating non functional requirements with functional requirements while we proposed that measurement of NFRs is possible e.g. cost and performance and NFR like usability can be scaled. Our novel hybrid approach integrates three things rather than two i.e. Functional Requirements (FRs), Measurable NFRs (M-NFRs) and Scalable NFRs (S-NFRs). We have also found the use of Fuzzy Logic and Likert Scale effective for handling of discretely measurable as well as scalable NFRs as these techniques can provide a simple way to arrive at a discrete or scalable NFR in contrast to vague, ambiguous, imprecise, noisy or missing NFR. Our approach can act as baseline for new NFR and aspect oriented frameworks by using all types of UML diagrams. | Measurable & Scalable NFRs using Fuzzy Logic and Likert Scale | 5,095 |
The main objective of this paper is to provide an optimized solution and algorithm for the execution of a workflow process by ensuring the data consistency, correctness, completeness among various tasks involved. The solution proposed provides a synchronized and failure free flow of execution among various tasks involved in a workflow process. A synchronizing agent is bound at a very low level, i.e. with the workflow activity or task to get the desired goals to be done and an algorithm is provided to show the execution of workflow process completely. | Agent based Model for providing optimized, synchronized and failure free
execution of workflow process | 5,096 |
In this paper we present a modeling methodology for BPMN, the standard notation for the representation of business processes. Our methodology simplifies the development of collaborative BPMN diagrams, enabling the automated creation of skeleton process diagrams representing complex choreographies. To evaluate and tune the methodology, we have developed a tool supporting it, that we apply to the modeling of an international patenting process as a working example. | ChOrDa: a methodology for the modeling of business processes with BPMN | 5,097 |
Model-driven design of software for safety-critical applications often relies on mathematically grounded techniques such as the B method. Such techniques consist in the successive applications of refinements to derive a concrete implementation from an abstract specification. Refinement theory defines verification conditions to guarantee that such operations preserve the intended behaviour of the abstract specifications. One of these conditions requires however that concrete operations have exactly the same signatures as their abstract counterpart, which is not always a practical requirement. This paper shows how changes of signatures can be achieved while still staying within the bounds of refinement theory. This makes it possible to take advantage of the mathematical guarantees and tool support provided for the current refinement-based techniques, such as the B method. | Refining interfaces: the case of the B method | 5,098 |
Propositional bounded model checking has been applied successfully to verify embedded software but is limited by the increasing propositional formula size and the loss of structure during the translation. These limitations can be reduced by encoding word-level information in theories richer than propositional logic and using SMT solvers for the generated verification conditions. Here, we investigate the application of different SMT solvers to the verification of embedded software written in ANSI-C. We have extended the encodings from previous SMT-based bounded model checkers to provide more accurate support for finite variables, bit-vector operations, arrays, structures, unions and pointers. We have integrated the CVC3, Boolector, and Z3 solvers with the CBMC front-end and evaluated them using both standard software model checking benchmarks and typical embedded applications from telecommunications, control systems and medical devices. The experiments show that our approach can analyze larger problems and substantially reduce the verification time. | SMT-Based Bounded Model Checking for Embedded ANSI-C Software | 5,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.