By Topic

Software Engineering, 2004. ICSE 2004. Proceedings. 26th International Conference on

Date 23-28 May 2004

Filter Results

Displaying Results 1 - 25 of 137
  • Oil and water? High performance garbage collection in Java with MMTk

    Publication Year: 2004 , Page(s): 137 - 146
    Cited by:  Papers (6)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (328 KB) |  | HTML iconHTML  

    Increasingly popular languages such as Java and C# require efficient garbage collection. This paper presents the design, implementation, and evaluation of MMTk, a Memory Management Toolkit for and in Java. MMTk is an efficient, composable, extensible, and portable framework for building garbage collectors. MMTk uses design patterns and compiler cooperation to combine modularity and efficiency. The resulting system is more robust, easier to maintain, and has fewer defects than monolithic collectors. Experimental comparisons with monolithic Java and C implementations reveal MMTk has significant performance advantages as well. Performance critical system software typically uses monolithic C at the expense of flexibility. Our results refute common wisdom that only this approach attains efficiency, and suggest that performance critical software can embrace modular design and high-level languages. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Software engineering for large-scale multi-agent systems - SELMAS'04

    Publication Year: 2004 , Page(s): 752 - 753
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (196 KB) |  | HTML iconHTML  

    The development of multiagent systems (MAS) is not a trivial task. In addition, with the advances in Internet technologies, MAS are undergoing a transition from closed to open architectures composed of a huge number of autonomous agents, which operate and move across different environments. In fact, openness introduces additional complexity to the system modeling, design and implementation. It also impacts on most quality attributes of MAS, including scalability, interoperability, reliability and adaptability. This paper brings together researchers and practitioners to discuss the current state and future direction of research in software engineering for open MAS. A particular interest is to understand those issues in the agent technology that make it difficult and/or improve the production of large open systems. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Agile development: evaluation and experience

    Publication Year: 2004
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (178 KB) |  | HTML iconHTML  

    Agile methods such as Extreme Programming, Crystal, Scrum, and others have attracted a lot of attention recently. Agile methods stress early and continuous delivery of software, welcome changing requirements, and value early feedback from customers. Agile methods seek to cut out inefficiency, bureaucracy, and anything that adds no value to a software product. Proponents of agile methods often see software specification and documentation as adding no value, which has led observers to conclude that agile development is nothing but unprincipled hacking, perhaps even an anarchic counter-reaction to bureaucratic, heavyweight software processes that demand ever more intermediate deliverables from developers. The purpose of this panel is to discuss under what circumstances agile methods work and don't work. Some of the key practices of agile methods are: scheduling according to feature priorities, incremental delivery of software, feedback from expert users, emphasis on face-to-face communication, pair development, minimalist design combined with refactoring, test-driven development, automated regression testing, daily integration, self-organizing teams, and periodic tuning of the methods. Working software is the primary measure of success. Find out what the latest practical experience with agile methods is and learn about the latest thinking in this area. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A fast assembly level reverse execution method via dynamic slicing

    Publication Year: 2004 , Page(s): 522 - 531
    Cited by:  Papers (3)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (371 KB) |  | HTML iconHTML  

    One of the most time consuming parts of debugging is trying to locate a bug. In this context, there are two powerful debugging aids which shorten debug time considerably: reverse execution and dynamic slicing. Reverse execution eliminates the need for repetitive program restarts every time a bug location is missed. Dynamic slicing, on the other hand, isolates code parts that influence an erroneous variable at a program point. In this paper, we present an approach which provides assembly level reverse execution along a dynamic slice. In this way, a programmer not only can find the instructions relevant to a bug, but also can obtain runtime values of variables in a dynamic slice while traversing the slice backwards in execution history. Reverse execution along a dynamic slice skips recovering unnecessary program state; therefore, it is potentially faster than full-scale reverse execution. The experimental results with four different benchmarks show a wide range of speedups from 1.3X for a small program with few data inputs to six orders of magnitude (1,928,500X) for 400x400 matrix multiply. Furthermore, our technique is very memory efficient. Our benchmark measurements show between 3.4X and 2240X memory overhead reduction as compared to our implementation of the same features using traditional approaches. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • SNIAFL: towards a static non-interactive approach to feature location

    Publication Year: 2004 , Page(s): 293 - 303
    Cited by:  Papers (10)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (290 KB) |  | HTML iconHTML  

    To facilitate software maintenance and evolution, a helpful step is to locate features concerned in a particular maintenance task. In the literature, both dynamic and interactive approaches have been proposed for feature location. In this paper, we present a static and non-interactive method for achieving this objective. The main idea of our approach is to use the information retrieval (IR) technology to reveal the basic connections between features and computational units in source code. Due to the characteristics of the retrieved connections, we use a static representation of the source code named BRCG to further recover both the relevant and the specific computational units for each feature. Furthermore, we recover the relationships among the relevant units for each feature. A premise of our approach is that programmers should use meaningful names as identifiers. We perform an experimental study based on a GNU system to evaluate our approach. In the experimental study, we present the detailed quantitative experimental data and give the qualitative analytical results. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Statestep: a tool for systematic, incremental specification

    Publication Year: 2004 , Page(s): 711 - 712
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (273 KB) |  | HTML iconHTML  

    Statestep is an interactive tool for editing and checking specifications based on the finite state machine (FSM) model. The tabular notation supported is a novel yet simple one, first developed to specify the external behaviour of a series of audio compact disc recorders. The technique helps to describe system behaviour in a systematic manner, intended principally to ensure that no unusual scenarios, or corner cases, are overlooked at the specification stage. The notation is readily understandable and can reduce or eliminate the need for internal events or other structuring primitives. It supports a naturally incremental approach to specification and seems especially suited to dealing with the kind of complexity that can arise in embedded user interfaces. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Getting results from search-based approaches to software engineering

    Publication Year: 2004 , Page(s): 728 - 729
    Cited by:  Papers (4)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (206 KB) |  | HTML iconHTML  

    Like other engineering disciplines, software engineering is typically concerned with near optimal solutions or those which fall within a specified applicable tolerance. More recently, search-based techniques have started to find application in software engineering problem domains. This area of search-based software engineering has its origins in work on search-based testing, which began in the mid 1990s. Already, search-based solutions have been applied to software engineering problems right through the development life cycle. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The Dublo architecture pattern for smooth migration of business information systems: an experience report

    Publication Year: 2004 , Page(s): 117 - 126
    Cited by:  Papers (2)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (272 KB) |  | HTML iconHTML  

    While the importance of multi-tier architectures for enterprise information systems is widely accepted and their benefits are well published, the systematic migration from monolithic legacy systems toward multi-tier architectures is known to a much lesser extent. In this paper we present a pattern on how to re-use elements of legacy systems within multi-tier architectures, which also allows for a smooth migration path. We report on experience we made with migrating existing municipal information systems towards a multitier architecture. The experience is generalized by describing the underlying pattern such that it can be re-used for similar architectural migration tasks. The emerged Dublo pattern is based on the partial duplication of business logic among legacy system and newly deployed application server. While this somehow contradicts the separation-of-concerns principle, it offers a high degree of flexibility in the migration process and allows for a smooth transition. Experience with the combination of outdated database technology with modern server-side component and Web services technologies is discussed. In this context, we also report on technology and architecture selection processes. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Fault localization using visualization of test information

    Publication Year: 2004 , Page(s): 54 - 56
    Cited by:  Papers (3)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (214 KB) |  | HTML iconHTML  

    Attempts to reduce the number of delivered faults in software are estimated to consume 50% to 80% of the development and maintenance effort according to J.S. Collofello ans S.N. Woodfield (1989). Among the tasks required to reduce the number of delivered faults, debugging is one of the most time-consuming according to T. Ball and S.G. Eick and Telcordia Technologies, and locating the errors is the most difficult component of this debugging task according to I. Vessey (1985). Clearly, techniques that can reduce the time required to locate faults can have a significant impact on the cost and quality of software development and maintenance. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Managing commitments and risks: challenges in distributed agile development

    Publication Year: 2004 , Page(s): 732 - 733
    Cited by:  Papers (7)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (209 KB) |  | HTML iconHTML  

    Software development is always a challenging undertaking and it requires high commitments from individuals who participate in it. Software development often involves new technology, challenging or unknown requirements, and tight schedules - making it particularly prone to several types of risk. These challenges are even more paramount in agile development and in distributed development, where the need for efficient information sharing is important, yet the distributed development makes it very difficult. This paper uses innovative learning methods to explore and to learn about these challenges and how to deal with them. The paper is partially based on presentations given by authors, but a major element in the paper is the case study that is introduced and in which will involve all the participants. The learning in the paper is strongly facilitated by participants' discussions and the insights generated in concrete problem solving situations. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Requirements engineering tools go mobile

    Publication Year: 2004 , Page(s): 713 - 714
    Cited by:  Papers (3)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (210 KB) |  | HTML iconHTML  

    Software tools that support or automate software engineering tasks are typically available on traditional desktop-based workstations. In contrast, mobile tools for requirements engineers offer considerable potential. In the last few years the capabilities of mobile devices such as personal digital assistants (PDAs) have advanced considerably. These devices now provide faster processing, increased storage, and improved connectivity. Hence, mobile computing will become a dominant computing paradigm. These developments let us envision mobile tools for RE that are sophisticated enough to be used in real-world projects. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Visual timed event scenarios

    Publication Year: 2004 , Page(s): 168 - 177
    Cited by:  Papers (6)  |  Patents (2)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (569 KB) |  | HTML iconHTML  

    Formal description of real-time requirements is a difficult and error prone task. Conceptual and tool support for this activity plays a central role in the agenda of technology transference from the formal verification engineering community to the real-time systems development practice. In this article we present VTS, a visual language to define complex event-based requirements such as freshness, bounded response, event correlation, etc. The underlying formalism is based on partial orders and supports real-time constraints. The problem of checking whether a timed automaton model of a system satisfies these sort of scenarios is shown to be decidable. Moreover, we have also developed a tool that translates visually specified scenarios into observer timed automata. The resulting automata can be composed with a model under analysis in order to check satisfaction of the stated scenarios. We show the benefits of applying these ideas to some case studies. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • JDBC checker: a static analysis tool for SQL/JDBC applications

    Publication Year: 2004 , Page(s): 697 - 698
    Cited by:  Papers (11)  |  Patents (3)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (316 KB) |  | HTML iconHTML  

    In data-intensive applications, it is quite common for the implementation code to dynamically construct database query strings and execute them. For example, a typical Java servlet Web service constructs SQL query strings and dispatches them over a JDBC connector to an SQL-compliant database. The servlet programmer enjoys static checking via Java's strong type system. However, the Java type system does little to check for possible errors in the dynamically generated SQL query strings. For example, a type error in a generated selection query (e.g., comparing a string attribute with an integer) can result in an SQL runtime exception. Currently, such defects must be rooted out through careful testing, or (worse) might be found by customers at runtime. In this paper, we describe JDBC Checker, a sound static analysis tool to verify the correctness of dynamically generated query strings. We have successfully applied the tool to find known and unknown defects in realistic programs using JDBC. We give a short description of our tool in this paper. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A model driven approach for software systems reliability

    Publication Year: 2004 , Page(s): 30 - 32
    Cited by:  Papers (3)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (215 KB) |  | HTML iconHTML  

    The main contribution of this research is to provide platform-independent means to support reliability design following the principles of a model driven approach. The contribution aims to systematically address dependability concerns from the early to the late stages of software development. MDA appears to be a suitable framework to assess these concerns and, therefore, semantically integrate analysis and design models into one environment. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A constraint architectural description approach to self-organising component-based software systems

    Publication Year: 2004 , Page(s): 81 - 83
    Cited by:  Papers (1)  |  Patents (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (273 KB) |  | HTML iconHTML  

    We propose a constraint-based structural architectural description language for specifying and reasoning about self-organising software architectures and for guiding their evolution. We also introduce a notion of tactics added into the new language so as to mitigate the NP-complete problem of constraint satisfaction used for self-organising the specified architectures. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Elaborating security requirements by construction of intentional anti-models

    Publication Year: 2004 , Page(s): 148 - 157
    Cited by:  Papers (63)  |  Patents (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (273 KB) |  | HTML iconHTML  

    Caring for security at requirements engineering time is a message that has finally received some attention recently. However, it is not yet very clear how to achieve this systematically through the various stages of the requirements engineering process. The paper presents a constructive approach to the modeling, specification and analysis of application-specific security requirements. The method is based on a goal-oriented framework for generating and resolving obstacles to goal satisfaction. The extended framework addresses malicious obstacles (called anti-goals) set up by attackers to threaten security goals. Threat trees are built systematically through anti-goal refinement until leaf nodes are derived that are either software vulnerabilities observable by the attacker or anti-requirements implementable by this attacker. New security requirements are then obtained as countermeasures by application of threat resolution operators to the specification of the anti-requirements and vulnerabilities revealed by the analysis. The paper also introduces formal epistemic specification constructs and patterns that may be used to support a formal derivation and analysis process. The method is illustrated on a Web-based banking system for which subtle attacks have been reported recently. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Software modeling techniques and the semantic Web

    Publication Year: 2004 , Page(s): 724 - 725
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (203 KB) |  | HTML iconHTML  

    Following the success of XML, W3C envisions the semantic Web (Berners-Lee et al., 2001) as the next generation of Web in which data are given well-defined and machine-understandable semantics so that they can be processed by intelligent software agents. Semantic Web can be regarded as an emerging area from the knowledge representation and the Web communities. The software engineering community can also play an important role in the semantic Web development. Modeling and verification techniques can be useful at many stages during the design, maintenance and deployment of semantic Web ontology. We believe semantic Web will be a new research and application domain for software modeling techniques and tools. For example, recent research results have shown that UML, Z (Woodcock and Davis, 1996) and Alloy (Jackson, 2002) can provide modeling, reasoning and consistency checking services for semantic Web. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Towards safe distributed application development

    Publication Year: 2004 , Page(s): 347 - 356
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (328 KB) |  | HTML iconHTML  

    Distributed application development is overly tedious, as the dynamic composition of distributed components is hard to combine with static safety with respect to types (type safety) and data (encapsulation). Achieving such safety usually goes through specific compilation to generate the glue between components, or making use of a single programming language for all individual components with a hardwired abstraction for the distributed interaction. In this paper, we investigate general-purpose programming language features for supporting third-party implementations of programming abstractions for distributed interaction among components. We report from our experiences in developing a stock market application based on type-based publish/subscribe (TPS) implemented (1) as a library in standard Java as well as with (2) a homegrown extension of the Java language augmented with specific primitives for TPS, motivated by the lacks of former implementation. We then revisit the library approach, investigating the impact of genericity, reflective features, and the type system, on the implementation of a satisfactory TPS library. We then discuss the impact of these features also on other distributed programming abstractions, and hence on the engineering of distributed applications in general, pointing out lacks of mainstream programming environments such as Java as well as .NET. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An open framework for dynamic reconfiguration

    Publication Year: 2004 , Page(s): 594 - 603
    Cited by:  Papers (12)  |  Patents (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (460 KB) |  | HTML iconHTML  

    Dynamic reconfiguration techniques appear promising for building systems that have requirements for adaptability and/or high availability. Current systems that support dynamic reconfiguration tend to use a single, fixed, reconfiguration algorithm to manage the change process. Furthermore, existing change management systems lack support for measuring the impact of reconfiguration on a running system. In this paper, we introduce OpenRec, an open framework for managing dynamic reconfiguration which addresses these drawbacks. Using OpenRec, developers can observe the costs, in terms of time and disturbance, associated with making a particular run-time change. In addition, OpenRec employs an extensible set of reconfiguration algorithms where one algorithm can be substituted for another. Developers can thus make an informed decision as to which algorithm to use based on comparative analysis. Finally, OpenRec is itself dynamically reconfigurable. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • DiscoTect: a system for discovering architectures from running systems

    Publication Year: 2004 , Page(s): 470 - 479
    Cited by:  Papers (15)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (411 KB) |  | HTML iconHTML  

    One of the challenging problems for software developers is guaranteeing that a system as built is consistent with its architectural design. In this paper, we describe a technique that uses run time observations about an executing system to construct an architectural view of the system. With this technique, we develop mappings that exploit regularities in system implementation and architectural style. These mappings describe how low-level system events can be interpreted as more abstract architectural operations. We describe the current implementation of a tool that uses these mappings, and show that it can highlight inconsistencies between implementation and architecture. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Feature-oriented programming and the AHEAD tool suite

    Publication Year: 2004 , Page(s): 702 - 703
    Cited by:  Papers (17)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (218 KB) |  | HTML iconHTML  

    Feature oriented programming (FOP) is an emerging paradigm for application synthesis, analysis, and optimization. A target application is specified declaratively as a set of features, like many consumer products (e.g., personal computers, automobiles). FOP technology translates such declarative specifications into efficient programs. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • AcmeStudio: supporting style-centered architecture development

    Publication Year: 2004 , Page(s): 704 - 705
    Cited by:  Papers (10)  |  Patents (7)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (386 KB) |  | HTML iconHTML  

    Software architectural modeling is crucial to the development of high-quality software. Tool support is required for this activity, so that models can be developed, viewed, analyzed, and refined to implementations. This support needs to be provided in a flexible and extensible manner so that the tools can fit into a company's process and can use particular, perhaps company-defined, domain-specific architectural styles. In this research demonstration, we describe AcmeStudio, a style-neutral architecture development environment that can be easily specialized for architectural design in different domains. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Unifying artifacts and activities in a visual tool for distributed software development teams

    Publication Year: 2004 , Page(s): 387 - 396
    Cited by:  Papers (22)  |  Patents (7)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (921 KB)  

    In large projects, software developers struggle with two sources of complexity - the complexity of the code itself, and the complexity of the process of producing it. Both of these concerns have been subjected to considerable research investigation, and tools and techniques have been developed to help manage them. However, these solutions have generally been developed independently, making it difficult to deal with problems that inherently span both dimensions. We describe Augur, a visualization tool that supports distributed software development processes. Augur creates visual representations of both software artifacts and software development activities, and, crucially, allows developers to explore the relationship between them. Augur is designed not for managers, but for the developers participating in the software development process. We discuss some of the early results of informal evaluation with open source software developers. Our experiences to date suggest that combining views of artifacts and activities is both meaningful and valuable to software developers. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Panel MDA in practice

    Publication Year: 2004 , Page(s): 691
    Save to Project icon | Request Permissions | PDF file iconPDF (191 KB)  
    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Static checking of dynamically generated queries in database applications

    Publication Year: 2004 , Page(s): 645 - 654
    Cited by:  Papers (27)  |  Patents (4)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (494 KB) |  | HTML iconHTML  

    Many data-intensive applications dynamically construct queries in response to client requests and execute them. Java servlets, e.g., can create string representations of SQL queries and then send the queries, using JDBC, to a database server for execution. The servlet programmer enjoys static checking via Java's strong type system. However, the Java type system does little to check for possible errors in the dynamically generated SQL query strings. Thus, a type error in a generated selection query (e.g., comparing a string attribute with an integer) can result in an SQL runtime exception. Currently, such defects must be rooted out through careful testing, or (worse) might be found by customers at runtime. In this paper, we present a sound, static, program analysis technique to verify the correctness of dynamically generated query strings. We describe our analysis technique and provide soundness results for our static analysis algorithm. We also describe the details of a prototype tool based on the algorithm and present several illustrative defects found in senior software-engineering student-team projects, online tutorial examples, and a real-world purchase order system written by one of the authors. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.