waashk/dblp huggingface dataset:
statemate; a working environment for the development of complex reactive systems. this paper provides a brief overview of the statemate system, constructed over the past three years by i-logix inc., and ad cad ltd. statemate is a graphical working environment, intended for the specification, analysis, design and documentation of large and complex reactive systems, such as real-time embedded systems, control and communication systems, and interactive software. it enables a user to prepare, analyze and debug diagrammatic, yet precise, descriptions of the system under development from three inter-related points of view, capturing, structure, functionality and behavior. these views are represented by three graphical languages, the most intricate of which is the language of statecharts used to depict reactive behavior over time. in addition to the use of state-charts, the main novelty of statemate is in the fact that it `understands` the entire descriptions perfectly, to the point of being able to analyze them for crucial dynamic properties, to carry out rigorous animated executions and simulations of the described system, and to create running code automatically. these features are invaluable when it comes to the quality and reliability of the final outcome.
seminal: software engineering using metaheuristic innovative algorithms. metaheuristic search algorithms have been widely applied to almost all engineering disciplines with the exception of software engineering. it is surprising that these essentially software driven technologies have not yet fully penetrated the software engineering research community and are not widely applied when compared to the more traditional engineering disciplines. this workshop aims to build the embryonic research community interested in the application of metaheuristic algorithms to software engineering problems.
workshop on technology transfer in software engineering. in many industries, the adoption of technology developed at universities and independent research labs is the prevalent paradigm. however, in the software space, this is a relatively rare occurrence. in many cases, academic software engineering tends to lag rather than lead commercial developments. the goal of this workshop is to open a dialouge between researchers and practitioners to address this problem.
reuse-driven interprocedural slicing. to manage the evolution of software systems effectively, software developers must understand software systems, identify and evaluate alternative modification strategies, implement appropriate modifications, and validate the correctness of the modifications. one analysis technique that assists in many of these activities is program slicing. to facilitate the application of slicing to large software systems, we adapted a control flow-based interprocedural slicing algorithm so that it accounts for interprocedural control dependencies not recognized by other slicing algorithms, and reuses slicing information for improved efficiency. our initial studies suggest that additional slice accuracy and slicing efficiency may be achieved with our algorithm
a retrospective on the development of star. star, officially known as the xerox 8010 information system, is a workstation for professionals, providing a comprehensive set of capabilities for the office environment. the star software consists of just over 250,000 lines of code. its development required 93 work years over a 3.5 year period. the development of star depended heavily on the use of powerful personal computers connected to a local-area network and on the use of the mesa language and development environment. an integration service was introduced to speed up the building of star and to relieve the programmers of many complex, but repetitive, tasks.
a scalable, automated process for year 2000 system correction. as the 21st century approaches, many computer programs will begin to fail. applications that rely on dates of any kind may simply stop working or produce incorrect results. the year 2000 problem is a matter of business importance, not just software maintenance. program failures arise from representing calendar dates (year, month, and day) in just 6 digits, a format that allows only 2 digits for the year. the year 2000 problem is pervasive. it occurs in calculations, comparisons and other logic involving date-related processing including date-oriented sorting and date-indexed tables. the problem occurs in databases and files as well as in code. the paper discusses the design of an automated software tool for code and data y2000 correction and shows how to use the tool in a large scale system correction process. the solution is discussed in the context of large, cobol-based commercial systems. nonetheless, our approach is fully generalizable to other languages and classes of applications.
understanding natural programs using proper decomposition. the author presents a practical method for automatic control concept recognition in large, unstructured imperative programs. control concepts are abstract notions about interactions between control flow, data flow, and computation, e.g., read-process loops. they are recognized by comparing a language-independent abstract program representation against standard implementation plans. recognition is efficient and scalable because the program representation is hierarchically decomposed by propers (single entry/exit control flow subgraphs). a recognition experiment using the unprog program understander shows the method's performance, the role of proper decomposition, and the ability to use standard implementations in a sample of programs. how recognized control concepts are used to perform cobol restructuring with quality not possible with existing syntactic methods is described
architecture recovery of web applications. web applications are the legacy software of the future. developed under tight schedules, with high employee turn over, and in a rapidly evolving environment, these systems are often poorly structured and poorly documented. maintaining such systems is problematic.this paper presents an approach to recover the architecture of such systems, in order to make maintenance more manageable. our lightweight approach is flexible and retargetable to the various technologies that are used in developing web applications. the approach extracts the structure of dynamic web applications and shows the interaction between their various components such as databases, distributed objects, and web pages. the recovery process uses a set of specialized extractors to analyze the source code and binaries of web applications. the extracted data is manipulated to reduce the complexity of the architectural diagrams. developers can use the extracted architecture to gain a better understanding of web applications and to assist in their maintenance.
msr 2004: international workshop on mining software repositories. the goal of this one-day workshop is to bring together researchersand practitioners to consider methods that use datastored in software repositories (such as source control systems,defect tracking systems, and archived project communications)to further understanding of software developmentpractices.
the dublo architecture pattern for smooth migration of business information systems: an experience report. while the importance of multi-tier architectures for enterpriseinformation systems is widely accepted and theirbenefits are well published, the systematic migration frommonolithic legacy systems toward multi-tier architectures isknown to a much lesser extent. in this paper we present apattern on how to re-use elements of legacy systems withinmulti-tier architectures, which also allows for a smooth migrationpath. we report on experience we made with migratingexisting municipal information systems towards a multitierarchitecture. the experience is generalized by describingthe underlying pattern such that it can be re-used forsimilar architectural migration tasks. the emerged dublopattern is based on the partial duplication of businesslogic among legacy system and newly deployed applicationserver. while this somehow contradicts the separation-of-concernsprinciple, it offers a high degree of flexibility inthe migration process and allows for a smooth transition.experience with the combination of outdated databasetechnology with modern server-side component and webservices technologies is discussed. in this context, we alsoreport on technology and architecture selection processes.
cadena: an integrated development, analysis, and verification environment for component-based systems. the use of component models such as enterprise java beans and the corba component model (ccm) in application development is expanding rapidly. even in real-time safety/mission-critical domains, component-based development is beginning to take hold as a mechanism for incorporating non-functional aspects such as real-time, quality-of-service, and distribution. to form an effective basis for development of such systems, we believe that support for reasoning about correctness properties of component-based designs is essential.in this paper, we present cadena -- an integrated environment for building and modeling ccm systems. cadena provides facilities for defining component types using ccm idl, specifying dependency information and transition system semantics for these types, assembling systems from ccm components, visualizing various dependence relationships between components, specifying and verifying correctness properties of models of ccm systems derived from ccm idl, component assembly information, and cadena specifications, and producing corba stubs and skeletons implemented in java. we are applying cadena to avionics applications built using boeing 's bold stroke framework.
conspectus of software engineering environments. aspects of software engineering environments are discussed, namely motivations, life cycle models, concepts, methods, description means and tools. some general conclusions about these aspects as well as about the area of software engineering environments are drawn. the paper is based on a study of selected software engineering environments.
detection of conflicting functional requirements in a use case-driven approach: a static analysis technique based on graph transformation. in object-oriented software development, requirements of different stakeholders are often manifested in use case models which complement the static domain model by dynamic and functional requirements. in the course of development, these requirements are analyzed and integrated to produce a consistent overall requirements specification. iterations of the model may be triggered by conflicts between requirements of different parties.however, due to the diversity, incompleteness, and informal nature, in particular of functional and dynamic requirements, such conflicts are difficult to find. formal approaches to requirements engineering, often based on logic, attack these problems, but require highly specialized experts to write and reason about such specifications.in this paper, we propose a formal interpretation of use case models consisting of uml use case, activity, and collaboration diagrams. the formalization, which is based on concepts from the theory of graph transformation, allows to make precise the notions of conflict and dependency between functional requirements expressed by different use cases. then, use case models can be statically analyzed, and conflicts or dependencies detected by the analysis can be communicated to the modeler by annotating the model.an implementation of the static analysis within a graph transformation tool is presented.
software engineering education in the era of outsourcing, distributed development, and open source software: challenges and opportunities. as software development becomes increasingly globally distributed, and more software functions are delegated to common open source software (oss) and commercial off-the-shelf (cots) components, practicing software engineers face significant challenges for which current software engineering curricula may leave them inadequately prepared. a new multi-faceted distributed development model is emerging that effectively commoditizes many development activities once considered integral to software engineering, while simultaneously requiring practitioners to apply engineering principles in new and often unfamiliar contexts. we discuss the challenges that software engineers face as a direct result of outsourcing and other distributed development approaches that are increasingly being utilized by industry, and some of the key ways we need to evolve software engineering curricula to address these challenges.
component design of retargetable program analysis tools that reuse intermediate representations. interactive program analysis tools are often tailored to one particular representation of programs, making adaptation to a new language costly. one way to ease adaptability is to introduce an intermediate abstraction&mdash;an adaptation layer&mdash;between an existing language representation and the program analysis tool. this adaptation layer translates the tool's queries into queries on the particular representation.our experiments with this approach on the startool program analysis tool resulted in low-cost retargets for c, tcl/tk, and ada. required adjustments to the approach, however, led to insights for improving a client's retargetability. first, retargeting was eased by having our tool import a tool-centric (i.e., client-centric) interface rather than a general-purpose, language-neutral representation interface. second, our adaptation layer exports two interfaces, a representation interface supporting queries on the represented program and a language interface that the client queries to configure itself suitably for the given language. straightforward object-oriented extensions enhance reuse and ease the development of multi-language tools.
evaluating individual contribution toward group software engineering projects. it is widely acknowledged that group or team projects are a staple of undergraduate and graduate software engineering courses. such projects provide students with experiences that better prepare them for their careers, so teamwork is often required or strongly encouraged by accreditation agencies. while there are a multitude of educational benefits of group projects, they also pose considerable challenge in fairly and accurately discerning individual contribution for evaluation purposes. issues, approaches, and best practices for evaluating individual contribution are presented from the perspectives of the university of kentucky, university of ottawa, university of southern california, and others.the techniques utilized within a particular course generally are a mix of (1) the group mark is everybody's mark, (2) everybody reports what they personally did, (3) other group members report the relative contributions of other group members, (4) pop quizzes on project details, and (5) cross-validating with the results of individual work.
building enterprise portals: principles to practice. primary objective of this paper is to offer an exclusive view of constructing and deploying enterprise portals by using a component-based development approach. as the dot-com hype dies down, most companies are forced to revisit their enterprise-wide web integration strategies. this paper offers a pragmatic roadmap that these companies may follow in their upcoming enterprise portal deployment initiatives.the academic world plays a significant role in the advances of the portal technology. in this paper, we address the challenges faced in building enterprise portals as a new principle of software engineering. we also explain how the academia will play a significant role in meeting most of these challenges.
teaching framework for software development methods. in this paper we suggest a framework for teaching software development methods (sdms). specifically, based on our accumulative research and in-practice experience of teaching sdms, a set of principles, that guides our teaching of sdms in different settings and teaching experiences, has been formulated. the teaching framework consists of 14 principles that their actual implementation is varied and adjusted in different teaching environments. this paper outlines the principles and addresses their contribution to learners' understanding of the said software development method.
teaching human aspects of software engineering. this paper highlights the teaching of human aspects of software engineering, by presenting a course that deals with this topic. specifically, this paper outlines the course's objective and structure, and, as the cfp asks, suggests two challenges an instructor of software engineering faces today.
introducing software engineering by means of extreme programming. this paper reports on experience from teaching basic software engineering concepts by using extreme programming in a second year undergraduate course taken by 107 students. we describe how this course fits into a wider programme on software engineering and technology and report our experience from running and improving the course. particularly important aspects of our setup includes team coaching (by older students) and "team-in-one-room". our experience so far is very positive and we see that students get a good basic understanding of the important concepts in software engineering, rooted in their own practical experience.
the causes and effects of infeasible paths in computer programs. an analysis is presented of infeasible paths found in the nag library of numerical algorithms. the construction of program paths designed to maximise structural testing measures is shown to be impossible without taking infeasibilities into account. methods for writing programs which do not contain infeasible paths are also discussed.
a new approach to consistency control in software engineering. quality assurance methods as suggested by standards like iso 9000 focus on the principle of review and feedback loops, which may be implemented by computer-based software process management including life cycle models, version control, and change tracking. provided that the software process is modelled independently of concrete design methods, development tools, and software representations, a general representation of quality assurance methods can be obtained. in our paper we introduce such a high-level formalism, heavily exploiting some remarkable analogy between the software development process and distributed computations. our approach is based on labelling each software element and product version during development. by using these labels one can coordinate versions, variant designs, and reconstruct elements of old versions automatically. though our model is independent of particular design methods or programming formalisms, it can be parameterized with tools and compilers in order to be tailored to specific projects. some applications are demonstrated for important problems of software project management that cannot be solved or even detected with nowadays standard methods, but that can easily be dealt with by using our new model.
dynamite: dynamic task nets for software process management. managing the software development and maintenance process has been identified as a great challenge for several years. software processes are highly dynamic and can only rarely be planned completely in advance. dynamic task nets take this into account. they are built and modified incrementally as a software process is executed. dynamic task nets have been designed to solve important problems of process dynamics, deciding product-dependent structure evolution, feedback, and concurrent engineering. in order to describe editing and enactment (and their interaction) in a uniform way, task nets are formally defined by means of a programmed graph rewriting system.
static detection of leaks in polymorphic containers. this paper presents the first practical static analysis tool that can find memory leaks and double deletions of objects held in polymorphic containers. this is especially important since most dynamically allocated objects are stored in containers.the tool is based on the concept of object ownership: every object has one and only one owning pointer. the owning pointer holds the exclusive right and obligation to either delete the object or to transfer the obligation. this paper presents a new type system that allows different instances of a polymorphic container to hold different types of elements, and to independently own or not own their elements.our tool is sound: it will report all potential memory leaks and multiple deletions of pointers in a program. our system automatically identifies the container implementation routines in an application. the user provides a short specification on the container structure and ownership constraints for these routines. the system then solves for the ownership constraints flow- and context-sensitively, and reports inconsistencies in ownership constraints as potential memory leaks and double deletions.we applied our tool to a suite of five large open-source and commercial c and c++ applications totaling one million lines of code. the tool successfully identified memory leaks in these programs and found double deletions of objects that could lead to program failures or security vulnerabilities.
introduction to the experience reports track. it is our great pleasure to welcome you to the experience reports track of the 27th international conference on software engineering (icse). the objective of the experience reports track is to establish a dialogue between software practitioners and software engineering researchers on the benefits, obstacles, and weaknesses of applying software engineering principles, techniques, methods, processes, and tools in an industrial or organizational setting. in the call for papers, we invited four types of submissions: case studies, experience reports, experimental reports and problem statements. the call attracted 72 submissions from all over the world. the program committee of the experience reports track accepted 14 submissions. the selection was based on at least three reviews per submission and the results of intensive consensus discussions prior to and during the experience reports track program committee meeting, held on november 12, 2004 in essen, germany.the accepted papers of the icse 2005 experience reports track cover topics such as agile methods, product lines, requirements engineering, software architecture, testing and verification. they document important lessons learned from applying software engineering principles, techniques, methods, processes, and tools in practice. putting together the experience reports track of icse 2005 was a team effort. we extend our sincerest gratitude to all of the people who helped us shape this event, especially to the members of our program committee and the icse 2005 organizing committee and to richard van de stadt, andreas metzger, and nelufar ulfat-bunyadi. we hope that you find the experience reports track of icse 2005 interesting and thought-provoking.