waashk/dblp huggingface dataset:
managing commitments and risks: challenges in distributed agile development. software development is always a challengingundertaking and it requires high commitments fromindividuals who participate in it. software developmentoften involves new technology, challenging or unknownrequirements, and tight schedules ¿ making itparticularly prone to several types of risk. thesechallenges are even more paramount in agiledevelopment and in distributed development, where theneed for efficient information sharing is important, yetthe distributed development makes it very difficult.this tutorial uses innovative and new learning methodsto explore and to learn about these challenges and howto deal with them. the tutorial is partially based onpresentations given by authors, but a major element inthe tutorial is the case study that is introduced and inwhich will involve all the participants. the learning inthe tutorial is strongly facilitated by participantsýdiscussions and the insights generated in concreteproblem solving situations.
process design system: an integrated set of software development tools. the process design engineering program, under the direction of the ballistic missile defense advanced technology center, has as its objective the development of a unified software engineering discipline addressing all software development problems from receipt of software requirements to delivery of the operational software system. during the first two years of this program, initial process design engineering and management procedures were developed which led to the systematic top-down development of real-time software processes. a prototype set of software tools to support these procedures was designed and implemented as process design system 1 (pds 1 ), and an experimental bmd baseline software process was then designed and implemented using these techniques and tools. the baseline experiment demonstrated that although the basic concepts employed were effective for the tactical software (1), there were several deficiencies in the process design tools. the most important deficiency stemmed from the fact that the system was designed to support the development of only the tactical software. this resulted in the operating system software (the most difficult component) being implemented without the aid of pds and in assembly language at cost of thirty percent of the budget for nine percent of the code. additional problem areas were the lack of positive control over data accessing, inadequate data structuring capability, and the interruption and synchronization of operations.
assertion-oriented automated test data generation. assertions are recognized as a powerful tool for automatic run time detection of software errors. however, existing testing methods do not use assertions to generate test cases. we present a novel approach of automated test data generation in which assertions are used to generate test cases. in this approach the goal is to identify test cases on which an assertion is violated. if such a test is found then this test uncovers an error in the program. the problem of finding program input on which an assertion is violated may be reduced to the problem of finding program input on which a selected statement is executed. as a result, the existing methods of automated test data generation for white box testing may be used to generate tests to violate assertions. the experiments have shown that this approach may significantly improve the chances of finding software errors as compared to the existing methods of test generation.
from uml to java, building a 3-tier architecture: case study. the successful use of object technology requires far more than simply the adoption of a modern software technology or notation such as uml, java, corba or com. what is crucial, is knowing how to use these technologies to build commercially robust software systems. in this session the speaker draws on his experience at nasa, at&t, ibm, nova gass, and other leading companies to illustrate the pitfalls and best practices of component based software development.
scene: using scenario diagrams and active text for illustrating object-oriented programs. scenario diagrams are a well-known notation for visualizing the message flow in object-oriented systems. traditionally, they are used in the analysis and design phases of software development to prototype the expected behavior of a system. we show how they can be used in reverse for understanding and browsing existing software. we have implemented a tool called scene (scenario environment) that automatically produces scenario diagrams for existing object-oriented systems. the tool makes extensive use of an active text framework providing the basis for various hypertext-like facilities. it allows the user to browse not only scenarios but also various kinds of associated documents, such as source code (method definitions and calls), class interfaces, class diagrams and call matrices.
model processing tools in uml. unified modeling language (uml) provides several diagram types viewing a system from different perspectives. in this research, we exploit logical relationships between different uml models. we propose operations to compare, merge, slice and synthesize uml diagrams based on these relationships. in the formal demonstration we show how statechart diagrams can be synthesized semi-automatically from a set of sequence diagrams using an interactive algorithm called mas. we also demonstrate how a class diagram, annotated with pseudocode presentations of key operations, can be synthesized from sequence diagrams, and how class diagrams and sequence diagrams can be sliced against each other.
the internet as a medium for software engineering experiments. empirical software engineering often faces the challenge of large variability of results among individual subjects. variability can be reduced by using a larger group of subjects, but such group quickly becomes too expensive. another challenge is finding a group of subjects that is representative of some relevant population of software engineers. this paper explores the potential of using the internet as the medium for software engineering experiments to address the problems of sample size and representativeness.
segras - a formal and semigraphical language combining petri nets and abstract data types for the specification of distributed systems. segras is formal language for writing and analyzing specifications of distributed software systems. it unifies algebraic specifications of abstract data types with high-level petri net specifications of nonsequential systems in a common syntactic and semantic framework. the data structure of a system, the information content of its local states, and static constraints to state changes are specified algebraically using positive conditional equations. dynamic behavior is specified by high level petri nets. each net defines a (distributed) initial state and a partial ordering in which state changing operations may happen. segras addresses advanced programming methodologies by offering facilities for modularization and parameterization, and a type system which supports polymorphism with dependent types, higher-order types, subtypes, and overloading. some examples are given to illustrate these language concepts.
distributed software engineering. the term &ldquo;distributed software engineering&rdquo; is ambiguous. it includes both the engineering of distributed software and the process of distributed development of software, such as cooperative work. this paper concentrates on the former, giving an indication of the special needs and rewards in distributed computing. in essence, we argue that the structure of these systems as interacting components is a blessing which forces software engineers towards compositional techniques which offer the best hope for constructing scalable and evolvable systems in an incremental manner. we offer some guidance and recommendations as to the approaches which seem most appropriate, particularly in languages for distributed programming, specification and analysis techniques for modelling and distributed paradigms for guiding design
exoskeletal software. the author advocates the use of a separate and explicit structural language to describe software architectures. the structural nature makes it amenable to both textual and graphical description. since it is a language, it can be used to support general descriptions and to provide the framework for checking interconnections. in addition, it can be used to generate and manage the system itself. this approach, initially under the guise of simple &ldquo;module interconnection languages&rdquo; (mil) and subsequently as &ldquo;configuration languages&rdquo;, provides generalised support for a wide variety of component and interaction types. generic (skeleton) architectures provide the means for reusing structures with different constituent components. dynamic constructs support explicit extension while constraining the potential structures of the system to those expressed as valid. further, change can be supported at the architectural level, either offline on the design or code, or dynamically on the system itself. system structure (architecture), separately and explicitly described, should be recognised as the unifying framework upon which to hang specification, design, construction and evolution of systems
the role of abstraction in software engineering. this workshop explores the concept of abstraction in software engineering at the individual, team and organization level. the aim is to explore the role of abstraction in dealing with complexity in the software engineering process, to discuss how the use of different levels of abstraction may facilitate performance of different activities, and to examine whether or not abstraction skills can be taught.
the specification and testing of quantified progress properties in distributed systems. there are two basic parts to the behavioral specification of distributed systems: safety and progress. in earlier work, we developed a tool to monitor progress properties of corba components specified using the temporal operator transient. in this paper, we address the specification and testing of transient properties that are quantified (over both bounded and unbounded domains). we categorize typical quantifications that arise in practical systems and discuss possible implementation strategies. we define functional transience, a subclass of quantified transient properties that can be monitored in constant space and time. we outline the design and implementation of a tool for testing these properties in corba components.
on the inference of configuration structures from source code. we apply mathematical concept analysis to the problem of inferring configuration structures from existing source code. concept analysis has been developed by german mathematicians over the last years; it can be seen as a discrete analogon to fourier analysis. based on this theory, our tool will accept source code, where configuration-specific statements are controlled by the preprocessor. the algorithm will compute a so-called concept lattice, which - when visually displayed - allows remarkable insight into the structure and properties of possible configurations. the lattice not only displays fine-grained dependencies between configuration threads, but also visualizes the overall quality of configuration structures according to software engineering principles. the paper presents a short introduction to concept analysis, as well as experimental results on various programs
global software development for the practitioner. this international workshop on global software development for the practitioner (gsd2006) was held in conjunction with the 28th international conference on software engineering (icse 2006) on may 23rd, 2006 in shanghai, china. the workshop was motivated by the industry trend towards developing software in globally distributed settings: geographically distributed teams, or outsourcing parts of the software development to other organizations in other parts of the world. topics presented and discussed in the workshop focused on grounded, practical strategies and techniques that address the geographic, temporal, organizational, and cultural boundaries inherent in global software projects.
tutorial: describing software architecture with uml. the presence of a solid architectural vision is a key discriminator in the success or failure of a software project. this tutorial examines what software architecture is and what it is not. it discusses and illustrates how to describe architecture through a set of design viewpoints and views and how to express these views in the uml, in the spirit of the new ieee standard 1471:2000:recommended practice for architectural description. the tutorial shows of how architectures drive the development process and how to capture architectural design patterns using the uml. it is illustrated by several widely applicable architectural patterns in different domain.
efficient exploration of service-oriented architectures using aspects. an important step in the development of large-scale distributed, reactive systems is the design of architectures that effectively support the systems' purposes. early prototypes help to decide upon the most effective architecture for a given situation. questions to answer include the boundaries of components, communication topologies and of replication. it is desirable to evaluate and compare architectures for functionality and quality attributes before implementing or changing the whole system. often, the effort required is prohibitive. in this paper we present an approach to efficiently create prototypes for service-oriented architectures using aspect-oriented programming techniques. we explain a procedure for transforming interaction based software specifications into aspectj programs. we show how to map the same set of interaction scenarios to different candidate architectures. this significantly reduces the effort required to explore architectural alternatives. we explain and evaluate our approach using the center tracon automation system as a running example.
understanding metamodeling. metamodeling not only directly underpins the specification of modeling languages such as the uml, but is also the foundation for making the omg's mda vision come true. this tutorial starts by motivating metamodeling as an advanced way of creating software and then goes on to explore its fundamental principles. in particular, important new metamodeling concepts such as the distinction between ontological and linguistic instance-of relationships, the unification of class and object facets and deep instantiation are introduced. a metamodeling framework suitable for mda is constructed step-by-step and then used to explain and critique the omg's various metamodeling technologies. this information furnishes modelers with the heuristics they need to more effectively utilize omg metamodeling technology and to know when metamodeling concepts are suitable and when they are not. the tutorial ends with some methodological advice on how to model in the presence of more than two modeling levels (objects & classes).
improved updating in relational dat base systems by deuter-shere algorithms. the need to ease the user's handling of data banks concerning natural insertions and deletions, requires more data independencies. a fundamental trend to 'normalize' relations in first and second normal forms has been indicated by codd and kent. when it comes to the third normal form, obscurities are spreading. this touches the very moment, when adequate content relations of programming morphologies to content realities are missing. as chamberlin, gray and traiger pointed out, a so called 'rectangle of a base relation' aids to clarify natural function dependencies. these indications have been further developed and advanced to a level, where each tuple and entity is subdivided into six deuter-criteria: 1. identity, 2. age, 3. association, 4. frequency, 5. significance and 6. truth. the validity of each criterion is related to all potential components within a relational data base. the metric data of each deuter criterion can be derived by analytical methods within three- and four dimensional realities in the model of a deuter-sphere. this leads to fundamental insertion- and deletion rules and an improved updating.
a form-based approach to human engineering methodologies. experience in the development and maintenance of software leads to the design of methodologies for different phases of the software engineering process. such methodologies attempt to usefully support the programmer's thought process for re-creating only good, standard patterns of programming without limiting creativity. however methodologies, as they are generally used, are limited in their impact on software quality. in this paper we present an approach for human engineering methodologies based on forms. the advantages of using a form-based interface for a software engineering environment are discussed by focusing on the design of forms, on the impact of forms on the software engineering process, and on the improved tool support facilitated by the standardization achieved by forms.
function point measurement from java programs. function point analysis (fpa) was proposed to help measure the functionality of software systems. it is used to estimate the effort required for the software development. however, it has been reported that since function point measurement involves judgment on the part of the measurer, differences for the same product may occur even in the same organization. also, if an organization tries to introduce fpa, fp will have to be measured from the past software developed there, and this measurement is cost-consuming. in this paper, we intend to examine the possibility to measure fp from source code automatically. at first, we propose measurement rules to count data and transactional functions for object-oriented program based on ifpug method and develop the function point measurement tool. then, we have applied the tool to practical java programs in a computer company and examined the difference between the fp values obtained by the tool and those of an fp measurement specialist. as the results, the number of data and transactional functions extracted by the tool is similar to ones by the specialist though for the classification of each function there is some difference between them.
requirements engineering for product families. in search for improved software quality and high productivity, software reuse has become a key research area. one of the most promising reuse approaches is product families. however, current practices in requirements engineering do not support product families. this paper describes a definition hierarchy method for requirements capturing, structuring, analysis and documentation. this method helps to identify architectural drivers of the product family and shows how different products in the family vary.
efficient authoring of software documentation using rapid7. this paper presents a method, developed in nokia, for efficient document authoring in software development projects. the method is called rapid7 (rapid production of documentation, 7 steps). the method improves traditional approach for document authoring in which work is typically started by informal initiative, and the actual writing of a document is a task performed by a single individual. traditional document authoring usually relies on inspections to verify the quality of the documentation. rapid7 addresses the document authoring problem by getting people involved in the documentation work earlier as a team in order to guarantee quality, calendar time efficiency, commitment and improved communication. this paper also compares rapid7 with some other similar approaches and presents results from a large-scale experiment with rapid7.
maintaining mental models: a study of developer work habits. to understand developers' typical tools, activities, and practices and their satisfaction with each, we conducted two surveys and eleven interviews. we found that many problems arose because developers were forced to invest great effort recovering implicit knowledge by exploring code and interrupting teammates and this knowledge was only saved in their memory. contrary to expectations that email and im prevent expensive task switches caused by face-to-face interruptions, we found that face-to-face communication enjoys many advantages. contrary to expectations that documentation makes understanding design rationale easy, we found that current design documents are inadequate. contrary to expectations that code duplication involves the copy and paste of code snippets, developers reported several types of duplication. we use data to characterize these and other problems and draw implications for the design of tools for their solution.
testing levels for object-oriented software. one of the characteristics of object-oriented software is the complex dependency that may exist between classes due to inheritance, association and aggregation relationships. hence, where to start testing and how to define an integration strategy are issues that require further investigation. this paper presents an approach to define a test order by exploiting a model produced during design stages (e.g., using omt, uml), namely the class diagram. our goal is to minimize the number of stubs to be constructed in order to decrease the cost of testing. this is done by testing a class after the classes it depends on. the novelty of the test order lies in the fact that it takes account of: (i) dynamic (polymorphism) dependencies; (ii) abstract classes that cannot be instantiated, making some testing levels infeasible. the test order is represented by a graph showing which testing levels must be done in sequence and which ones may be done independently. it also provides information about the classes involved in each level and how they are involved (e.g., instantiation or not). the approach is implemented in a tool called toons (testing level generator for object-oriented software). it is applied to an industrial case study from the avionics domain.
specification of time dependencies and synthesis of concurrent processes. there is a need to incorporate reasoning about time dependencies into program synthesis systems. such dependencies have often been phrased in terms of temporal logic systems. we present an alternative method of specifying time dependencies, in a calculus of binary relations between time intervals [lad86.1, lad86.2]. we show how the interval calculus may be used to give very-high-level specifications of concurrent process protocols, and how these specifications may be automatically refined using interval calculus into a target specification language. we indicate how the target language may be executed, under certain sequencing assumptions.
explicit assumptions enrich architectural models. design for change is a well-known adagium in software engineering. we separate concerns, employ well-designed interfaces, and the like to ease evolution of the systems we build. we model and build in changeability through parameterization and variability points (as in product lines). these all concern places where we explicitly consider variability in our systems. we conjecture that it is helpful to also think of and explicitly model invariability, things in our systems and their environment that we assume will not change. we give examples from the literature and our own experience to illustrate how evolution can be seriously hampered because of tacit assumptions made. in particular, we show how we can explicitly model assumptions in an existing product family. from this, we derive a metamodel to document assumptions. finally, we show how this type of modeling adds to our understanding of the architecture and the decisions that led to it.