waashk/dblp huggingface dataset:
software architecture in an open source world. in spite of the hype and hysteria surrounding open source software development, there is very little that can be said of open source in general. open source projects range in scope from the miniscule, such as the thousands of non-maintained code dumps left behind at the end of class projects, dissertations, and failed commercial ventures, to the truly international, with thousands of developers collaborating, directly or indirectly, on a common platform. one characteristic that is shared by the largest and most successful open source projects, however, is a software architecture designed to promote anarchic collaboration through extensions while at the same time preserving centralized control over the interfaces.this talk features a survey of the state-of-the-practice in open source development in regards to software architecture, with particular emphasis on the modular extensibility interfaces within several of the most successful projects, including apache httpd, eclipse, mozilla firefox, linux kernel, and the world wide web (which few people recognize as an open source project in itself). these projects fall under the general category of collaborative open source software development, which emphasizes community aspects of software engineering in order to compensate for the often-volunteer nature of core developers and take advantage of the scalability obtainable through internet-based virtual organizations.
principled design of the modern web architecture. the world wide web has succeeded in large part because its software architecture has been designed to meet the needs of an internet-scale distributed hypermedia application. the modern web architecture emphasizes scalability of component interactions, generality of interfaces, independent deployment of components, and intermediary components to reduce interaction latency, enforce security, and encapsulate legacy systems. in this article we introduce the representational state transfer (rest) architectural style, developed as an abstract model of the web architecture and used to guide our redesign and definition of the hypertext transfer protocol and uniform resource identifiers. we describe the software engineering principles guiding rest and the interaction constraints chosen to retain those principles, contrasting them to the constraints of other architectural styles. we then compare the abstract model to the currently deployed web architecture in order to elicit mismatches between the existing protocols and the applications they are intended to support.
process issues in course projects. defined software engineering process help teaching and guiding software engineering courses projects. however, using them raises several issues related to process and course features. architecture issues relate to matching process and course lifecycle models. size issues address project scope and extent. support issues deal with student and instructor materials and tools.
a software process for time-constrained course projects. defined software engineering processes help to perform and guide software engineering course projects. however, several difficult issues are involved in designing a software process for this purpose. this design is even harder when it must suit time-constrained course projects. here, we discuss several issues concerning such processes, focusing on an educational setting.
software engineering education: a place in the sun? virtually every research specialisation in software engineering would be prepared to claim that its particular concern is the most important in the field. the author wishes to claim such a status for software engineering education, a specialisation barely regarded as respectable among the majority of researchers. what are the grounds for this claim? virtually all the technologies which we believe hold promise of improving software development are dependent on professionally skilled and educated staff. software engineering education remains our most powerful means of technology transfer and hence of narrowing the gap between what is known in the research community and what is applied in industry and commerce. despite economic hiccups the skills shortage is still a critical component of the omnipresent software crisis. industry is spending a large proportion of its software development budget on training and on recruitment to offset the costs of fundamental education problems
assessment of system evolution through characterization. owing to the growing diffusion of the object-oriented paradigm and the need to keep the process of software development under control, industries are looking for metrics/indicators capable of evaluating system evolution to control quality, reusability, maintainability, etc. some new metrics are proposed for monitoring system development and maintenance. these metrics are used with a set of histograms to give a clear characterization of the system under development. histograms call be profitably used to detect critical conditions during the system life-cycle. the semantics of these histograms has been validated against several projects: an example is also reported
engineering safety-related requirements for software-intensive systems. many software-intensive systems have significant safety ramifications and need to have their associated safety-related requirements properly engineered. however, there is little effective interaction and collaboration between the requirements and safety teams on most projects. this tutorial is intended to improve such collaboration by providing clear definitions of the different kinds of safety-related requirements, examples of such requirements, and a generic process for producing them.
engineering safety-related requirements for software-intensive systems. many software-intensive systems have significant safety ramifications and need to have their associated safety-related requirements properly engineered. it has been observed by multiple consultants, researchers, and authors that inadequate requirements are a major cause of accidents involving software-intensive systems. yet in practice, there is very little interaction between the requirements and safety disciplines and little collaboration between their respective communities. most requirements engineers know little about safety engineering, and most safety engineers know little about requirements engineering. also, safety engineering typically concentrates on architectures and designs rather than requirements because hazard analysis typically depends on the identification of hardware and software components, the failure of which can cause accidents. this leads to safety-related requirements that are often ambiguous, incomplete, and even missing. the tutorial begins with a single common realistic example of a safety critical system that will be used throughout to provide good examples of safety-related requirements. the tutorial then provides an introduction to requirements engineering for safety engineers and an introduction to safety engineering for requirements engineers. the tutorial then provides clear definitions and descriptions of the different kinds of safety-related requirements and finishes with a practical process for producing them.
software engineering themes for the future. the objective of this tutorial is to provide the participants with opportunities to think differently about future challenges facing software engineering research and practice. collaborative design, social creativity, and meta-design are identified as themes that will be of great importance in the years to come. the concept of design is used very broadly affecting all aspects of the process of creating, using, and evolving software-intensive systems. stakeholders coming from different disciplines and engaging in collaborative design can contribute to social creativity by exploring new approaches, new problems, and new visions. meta-design is a methodology empowering users to act not only as passive consumers but as active contributors and designers, thereby facilitating and supporting social creativity.the themes of the tutorial will be illustrated with specific theoretical frameworks and innovative systems. the relevance of these themes has been demonstrated by their desirability and importance on research, education, and design practices in companies, educational institutions, and research organizations.
cognitive tools for locating and comprehending software objects for reuse. the authors describe a conceptual framework to facilitate software reuse. it is shown that high functionality computer systems by themselves do not provide sufficient support for software reuse. two systems that support this framework, codefinder and explainer, are presented. codefinder addresses issues on information access for software reuse. support for comprehending software objects is demonstrated with explainer. a scenario describing how the two systems are used in a reuse situation is presented. the authors show how these systems fit into the bigger pictures of software development environments, address limitations of the systems, and discuss future directions
from design to redesign. software engineering environments have to support design methodologies whose main activity is not the generation of new independent programs, but the maintenance, integration, modification and explanation of existing ones. especially for software systems in ill-structured problem domains where detailed specifications are not available (like artificial intelligence and human-computer communication), incremental, evolutionary redesign has to be efficiently supported.to achieve this goal we have designed and constructed an object-oriented, knowledge-based user interface construction kit and a large number of associated tools and intelligent support systems to be able to exploit this kit effectively. answers to the &ldquo;user interface design question&rdquo; are given by providing appropriate building blocks that suggest the way user interfaces should be built. the object-oriented system architecture provides great flexibility, enhances the reusability of many building blocks, and supports redesign. because existing objects can be used either directly or with minor modifications, the designer can base a new user interface on standard and well-tested components.
knowledge-based communication processes in software engineering. a large number of problems to be solved with the help of computer systems are ill-structured. their solution requires incremental design processes, because complete and stable specifications are net available. for tasks of this sort, life cycle models are inadequate. our design methodology is based on a rapid prototyping approach which supports the coevolution of specification and implementation. communication between customers, designers and implementors and communication between the humans and the knowledge base in which the emerging product is embedded are of crucial importance. our work is centered around knowledge-based systems which enhance and support the communication needs in connection with software systems. program documentation systems are used as an example to illustrate the relevance of knowledge-based human-computer communication in software engineering.
the interaction between the preliminary designs and the technical requirements for the dod common high order language. the common high order language effort began in january 1975 as part of a dod wide program to reduce the cost and to improve the quality of its software. the effort is an attempt to create a situation in which software for new embedded computer systems are developed and maintained using a minimal number of general-purpose programming languages, and that those languages be suited to the applications, be widely used in dod, and be well supported.
automated test case generation for spreadsheets. spreadsheet languages, which include commercial spreadsheets and various research systems, have had a substantial impact on end-user computing. research shows, however, that spreadsheets often contain faults. thus, in previous work, we presented a methodology that assists spreadsheet users in testing their spreadsheet formulas. our empirical studies have shown that this methodology can help end-users test spreadsheets more adequately and efficiently; however, the process of generating test cases can still represent a significant impediment. to address this problem, we have been investigating how to automate test case generation for spreadsheets in ways that support incremental testing and provide immediate visual feedback. we have utilized two techniques for generating test cases, one involving random selection and one involving a goal-oriented approach. we describe these techniques, and report results of an experiment examining their relative costs and benefits.
verification and change-impact analysis of access-control policies. sensitive data are increasingly available on-line through the web and other distributed protocols. this heightens the need to carefully control access to data. control means not only preventing the leakage of data but also permitting access to necessary information. indeed, the same datum is often treated differently depending on context.system designers create policies to express conditions on the access to data. to reduce source clutter and improve maintenance, developers increasingly use domain-specific, declarative languages to express these policies. in turn, administrators need to analyze policies relative to properties, and to understand the effect of policy changes even in the absence of properties.this paper presents margrave, a software suite for analyzing role-based access-control policies. margrave includes a verifier that analyzes policies written in the xacml language, translating them into a form of decision-diagram to answer queries. it also provides semantic differencing information between versions of policies. we have implemented these techniques and applied them to policies from a working software application.
global talent and innovation. in his groundbreaking 2002 bestseller the rise of the creative class, economist richard florida identified the 3 ts of economic development: technology, talent, and tolerance. now, with the flight of the creative class, florida is back - and he's gone global. how does the movement of talented people across borders affect regional growth? what do tighter immigration, faltering education systems, and strong international competition mean for u.s. growth? who are the up-and-comers in the global creative economy? florida takes on these questions and more as he charts a course for creativity in the 21st century - and explains what the impact will be for countries, cities, and companies the world over.
modeling software tools with icon. this paper describes a new software test automation tool, a powerful new programming language, and the software development process that resulted when these tools were combined. a small development team of software developers and potential customers devised the unconventional process to meet a short deadline. the process produced an operational prototype or model of the entire software system that customers were able to use during the time it was being developed. the first model of the buster&trade; automated testing system was conceived, designed, and implemented ahead of schedule in less than six months, complete with many features and components. the buster system provides a test-information subsystem with facilities for multi-project test sharing, per-project test storage and planning, and test downloading for lab use. a separate test execution facility is also included that features test-result logging, a results database, and per-session i/o recording. the customer, at&t 3b4000 system test, reports that system soak tests that had taken three weeks now can be completed in one week, using buster. the software modeling technique that was used to create the buster test system is a new idea that can be used to produce reliable low-cost software in many applications. unlike more conventional software engineering approaches, including rapid prototyping, the model can be used by customers as it is slowly evolved into a finished product. the model is used to embody and test designs and identify missing requirements before making large investments in production level code and documentation. in addition, software modeling makes it possible to develop comprehensive system test suites long before production level software is available. the process is composed of three major components: brainstorming and team building with customers, high-level language engineering, and automated software testing.
an exact array reference analysis for data flow testing. data-flow testing is a well-known technique, and it has proved to be better than the commercially-used branch testing. the problem with data-flow testing is that, apart from scalar variables, only approximate information is available. this paper presents an algorithm that precisely determines the definition-use pairs for arrays within a large domain. there are numerous methods addressing the array data-flow problem; however, these methods are only used in the optimization or parallelization of programs. data-flow testing, however, requires at least one real solution of the problem for which the necessary program path is executed. contrary to former precise methods, we avoid negation in formulae, which seems to be the biggest problem in all previous methods.
on the time overhead of counters and traversal markers. the problem of minimizing the time overhead of counters and traversal markers is studied. the methodology used to study the problem is based upon markov processes. a fundamental result is presented that characterizes those flowcharts where the problem can be solved uniquely in the case of counters. two methods are described that avoid poor choices of counter placement by choosing counter placements from a dominating set. with respect to the problem of traversal marker placement, the basic result that traversal markers must be placed on the complement of a uni-connected sub-graph is extended to flowcharts with circuits. finally it is shown that complements of uni-connected subgraphs that are minimal in size may not have minimal time overheads.
global data flow analysis by decomposition into primes. the concept of prime program is applied as a decomposition technique to the global data flow analysis problem. this is done both in the abstract and through the use of the live variables problem as an example. it is also shown how the prime program decomposition is equivalent to the arrangement of a certain matrix (associated with the global data flow analysis problem) into block triangular form.
an algebra for data flow anomaly detection. an algebra a is developed that is specialized for the detection of data flow anomalies by interpreting the regular expression for the paths in a program as an a expression. two methods are subsequently presented that use a but do not require the explicit computation of the regular expression for the paths. one method is based on the prime program decomposition. the other is based upon the iterative algorithms of global data flow analysis. in addition the use of the algebra to get better warning messages than just the detection of anomalies is presented.
the detection of anomalous interprocedural data flow. in an earlier paper, the authors have defined type 1 and type 2 data flow anomalies to be, respectively, the reference to an undefined variable and the definition of a variable without subsequent reference. it is not difficult to devise search techniques to detect such anomalies when the anomalous data flow is contained in a single procedure. when the data flow crosses procedure boundaries, however, many difficulties may arise. in this paper, we carefully define the conditions under which interprocedural anomalies occur. we also show how algorithms currently used in global program optimization can easily be adapted to yield highly efficient algorithms for the detection of such interprocedural anomalies.
ltsa-ws: a tool for model-based verification of web service compositions and choreography. in this paper we describe a tool for a model-based approach to verifying compositions of web service implementations. the tool supports verification of properties created from design specifications and implementation models to confirm expected results from the viewpoints of both the designer and implementer. scenarios are modeled in uml, in the form of message sequence charts (mscs), and then compiled into the finite state process (fsp) process algebra to concisely model the required behavior. bpel4ws implementations are mechanically translated to fsp to allow an equivalence trace verification process to be performed. by providing early design verification and validation, the implementation, testing and deployment of web service compositions can be eased through the understanding of the behavior exhibited by the composition. the approach is implemented as a plug-in for the eclipse development environment providing cooperating tools for specification, formal modeling, verification and validation of the composition process.
refactoring. this tutorial is an example driven introduction to refactoring: a disciplined approach to changing the design of an existing code base.
information systems architecture. this tutorial provides an overview of patterns and principles that we've found useful in designing business information systems.
uml for software engineers. this tutorial presents the modeling concepts of the standard object modeling language, the unified modeling language (uml). particular attention is paid to the use of the uml for modeling system/software requirements and designs. a system development process and an example of its application is presented. the materials will be based on the recently released uml 1.4 standard. the tutorial also presents some of the major issues and challenges facing the evolution of the uml.
an interactive debugger for a concurrent language. this work deals with issues of interactive debugging for the concurrent language ecsp. the debugger matches a formal specification of the expected behavior of a program against its actual behaviour. this specification can be given at different levels of abstraction. control is returned to the user when an error is detected. the user can then modify the flow of the computation and/or dynamically change the specification of the expected behavior. the debugger implementation is based on program transformation techniques.
a hybrid architectural style for distributed parallel processing of generic data streams. immersive, interactive applications grouped under theconcept of immersipresence require on-line processing andmixing of multimedia data streams and structures. one criticalissue seldom addressed is the integration of differentsolutions to technical challenges, developed independentlyin separate fields, into working systems, that operateunder hard performance constraints. in order to realizethe immersipresence vision, a consistent, generic approachto system integration is needed, that is adapted tothe constraints of research development. this paper introducessai, a new software architecture model for designing,analyzing and implementing applications performing distributed,asynchronous parallel processing of generic datastreams. sai provides a universal framework for the distributedimplementation of algorithms and their easy integrationinto complex systems that exhibit desirable softwareengineering qualities such as efficiency, scalability, extensibility,reusability and interoperability. the sai architecturalstyle and its properties are described. the use of saiand of its supporting open source middleware (mfsm) is illustratedwith integrated, distributed interactive systems.