waashk/dblp huggingface dataset:
hardware/software codesign: a perspective. the authors propose that rather than maintain the traditional distinction between hardware and software engineering, a more fruitful approach to computer system design is to combine the hardware and software perspectives from the earliest stages of the design process and exploit the design flexibility and efficient allocation of function that such an approach offers. since current hardware and software design methodologies have their differences, a unified codesign approach must be developed that will comprise both the hardware and software points of view. increasingly, computer system design of the future will require this codesign approach. custom chip design and asic design are discussed. issues in codesign are considered
an analytical comparison of the fault-detecting ability of data flow testing techniques. compares several data flow based software testing criteria to one another and to branch testing. the fact that criterion c1 subsumes criterion c2, does not guarantee that c1 is better at detecting faults than c2. however, if a certain stronger relation between the criteria holds, then for any program and any specification, c1 is guaranteed to be better at detecting faults than c2 in the following sense: a test suite selected by independent random selection of one test case from each c1 subdomain is at least as likely to detect a fault as a suite similarly selected using c2. it is shown that under those conditions, the expected number of failure-causing inputs in the c1 test suite. these results are used to compare a number of data flow testing criteria to one another and to branch testing
effective identification of source code authors using byte-level information. source code author identification deals with the task of identifying the most likely author of a computer program, given a set of predefined author candidates. this is usually .based on the analysis of other program samples of undisputed authorship by the same programmer. there are several cases where the application of such a method could be of a major benefit, such as authorship disputes, proof of authorship in court, tracing the source of code left in the system after a cyber attack, etc. we present a new approach, called the scap (source code author profiles) approach, based on byte-level n-gram profiles in order to represent a source code author's style. experiments on data sets of different programming-language (java or c++) and varying difficulty (6 to 30 candidate authors) demonstrate the effectiveness of the proposed approach.a comparison with a previous source code authorship identification study based on more complicated information shows that the scap approach is language independent and that n-gram author profiles are better able to capture the idiosyncrasies of the source code authors. moreover, the scap approach is able to deal surprisingly well with cases where only a limited amount of very short programs per programmer is available for training. it is also demonstrated that the effectiveness of the proposed model is not affected by the absence of comments in the source code, a condition usually met in cyber-crime cases.
trustworthy and sustainable operations in marine environments. in order to address challenges and opportunities of engineering information systems for network-centric warfare, we have developed a prototype for trustworthy and sustainable operations in marine environments (twosome). the system developed addressed qualities such as information fusion, target acquisition, and self-organization in open computational systems; comprised of distributed services. as such, the system prototype executes on a service-oriented layered architecture for communicating entities (solace) and, furthermore, different perspectives of the prototype are visualized by means of a distributed interaction system for complex entity relation networks (discern).
a proposed curriculum for software engineering education. we propose a curriculum for a graduate professional degree in software engineering. after presenting the instructional objectives to be met by this curriculum, we present its underlying philosophy and assumptions. a number of suggestions are made for implementing the curriculum. in particular, we emphasize that this is a specific curriculum (for a master's degree) which can serve as a starting point for the development of other software engineering curricula.
essential elements of software engineering education. software engineering involves the application of principles of computer science, management science, and other fields to the design and construction of software systems. education in software engineering is fundamentally different from education in computer science, management science, or other constituent fields, even though it shares a large common area of concern. as we move toward the development of coordinated software engineering curricula, it is mandatory that we identify principles, not just random collections of techniques, on which to build them. our research, teaching, and practical experience leads us to argue for five essential elements of any software engineering curriculum: computer science, management science, communication skills, problem solving, and design methodology. this paper will discuss these areas, illustrate their current application in courses, and indicate their implications for curriculum development.
refactoring-aware version control. today, refactorings are supported in some integrated development environments (ides). the refactoring operations can only work correctly if all source code that needs to be changed is available to the ide. however, this precondition neither holds for application programming interface (api) evolution, nor in team development. the research presented in this paper aims to support refactoring in api evolution and team development by extending ide and version control to allow refactoring-aware merging and migration.
architectural framework modeling in telecommunication domain. architectural frameworks have been shown to increase the design reusability in large-scale object-oriented systems. drawing on experience in complex software systems development in the telecommunication domain, we present concepts and techniques for domain partitioning and an architectural framework modeling and layering. in particular, we discuss how a component-based approach, architectural modeling styles, and the systematic usage of architectural and design patterns provide a common framework for product-line development. two application frameworks based on this model are presented as case studies.
dynalloy: upgrading alloy with actions. we present dynalloy, an extension to the alloy specification language to describe dynamic properties of systems using actions. actions allow us to appropriately specify dynamic properties, particularly, properties regarding execution traces, in the style of dynamic logic specifications.we extend alloy's syntax with a notation for partial correctness assertions, whose semantics relies on an adaptation of dijkstra's weakest liberal precondition. these assertions, defined in terms of actions, allow us to easily express properties regarding executions, favoring the separation of concerns between the static and dynamic aspects of a system specification.we also extend the alloy tool in such a way that dynalloy specifications are also automatically analyzable, as standard alloy specifications. we present the foundations, two case-studies, and empirical results evidencing that the analysis of dynalloy specifications can be performed efficiently.
mgen - a generator for menu driven programs. many interactive computer applications can with advantage be built after the menu principle. mgen is a program that automatically builds a skeleton of a menu driven program. it is a well known problem that users of programs normally cannot state what they really want until they see the finished program running. with mgen, the resulting program can be simulated by the use of examples. to enable efficient utilization by skilled users, a feature called &ldquo;quick selection&rdquo; is implemented.
unifying artifacts and activities in a visual tool for distributed software development teams. in large projects, software developers struggle with two sources of complexity ¿ the complexity of the code itself, and the complexity of 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.
the intertwining between risk and project management. this summary recalls the aims of the tutorial, describes its main topics and lists its contents.
examples of applying software estimate tool. although estimating the cost of a software project and the effort involved is very important, improving accuracy and establishing the software as a technology are both difficult. to solve these problems we have tried to use a software estimating tool. this tool has two characteristics. the first is that the tool uses function point analysis (fpa) instead of source lines of code, and the second is that special factors present in software development (usually estimated only from experience) are considered. this report provides some examples of how software project effort estimates can be improved
prompter: a knowledge based support tool for code understanding. as an experiment for the application of knowledge-based techniques to large-scale software maintenance, a program called prompter which produces annotations for programs written in an assembly language is being developed. prompter adopts object-oriented approach and represents both hardware and programming knowledge as class/instance definitions. object-oriented representation helps decompose the knowledge and organize it in a hierarchical way. it is shown that most of conventions such as data definitions which are the major obstacles to understanding system programs can be well formalized in this framework.
efficiency analysis of model-based review in actual software design. in this paper, we quantitatively analyze the efficiency of the model-based review (mbr) method in an actual software design from the two points of view; cost and reviewability. the mbr method is a modeling procedure for the purpose of reviewing preliminary design specifications of web-based applications. we have collected process data in applying both of the mbr method and an ordinary review to a preliminary design of a developing web-based library system. analyzing the collected process data, we quantitatively compare the efficiency of the mbr method and that of the ordinary review. as a result of this comparative analysis, we show that the mbr method is superior to the ordinary review in terms of not only reviewability but also cost through the experimental design process.
development of computer programs by problem analysis diagram (pad). a new tree-structured diagram for describing computer program logics is presented. the diagraming technique called pad(problem analysis diagram) is used as basis in establishing method of coding, testing, and data type description. it is proposed as a functionally superior substitute for flowcharts. the fact that some 1000 hitachi programmers have converted from flowcharts to pad within the last 15 months is indicative of the broad potential utility of this notation.
parameterized programming in obj2. parameterized programming [9] is a powerful technique for the construction, maintenance, and reuse of software. in this technique, modules may be parameterized over very general interfaces that describe what properties of an environment are required for the module to work correctly. ease of construction, maintenance, and reuse of software are all enhanced by the flexibility of the parameterization mechanism provided.obj2 [8] is designed to support parameterized programming, using algebraic specification techniques [2, 16, 17]; it provides facilities for user-definable abstract data types, parameterized
a hierarchical structuring method for functional software systems. a hierarchical structuring method for functional software systems is described. this method is greatly influenced by the authors experiences in developing the experimental hierarchical software processor (hisp) during the last four years. in this paper, however, the method is described in a general setting. this method appears to be applicable to a broad class of functional software systems. we first describe the words &ldquo;functional&rdquo; and &ldquo;hierarchical&rdquo;. then the hierarchical structuring method is presented. some applications of this method are also discussed. in particular, an example of transformational programming based on this structuring method is presented. the truncated syntax diagrams of the hisp language are also given as an appendix.
the design of a reliable applications system. the design of tactics, a large interactive statistical analysis and modelling system which has proven highly reliable is presented. overall reliability was achieved by first identifying and then focusing on the critical system components. these are enumerated and their design described in detail.
software evolution: analysis and visualization. gaining higher level evolutionary information about large software systems is a key challenge in dealing with increasing complexity and decreasing software quality. software repositories such as modifications, changes, or release information are rich sources for distinctive kinds of analyses: they reflect the reasons and effects of particular changes made to the software system over a certain period of time. if we can analyze these repositories in an effective way, we get a clearer picture of the status of the software. software repositories can be analyzed to provide information about the problems concerning a particular feature or a set of features. hidden dependencies of structurally unrelated but over time logically coupled files exhibit a high potential to illustrate software evolution and possible architectural deterioration. in this tutorial, we describe the investigation of software evolution by taking a step towards reflecting the analysis results against software quality attributes. different kinds of analyses (from architecture to code) and their interpretation will be presented and discussed in relation to quality attributes. this will show our vision of where such evolution investigations can lead and how they can support development. for that, the tutorial will touch issues such as meta-models for evolution data, data analysis and history mining, software quality attributes, as well as visualization of analysis results.
agile, open source, distributed, and on-time: inside the eclipse development process. eclipse is a widely recognized open source project dedicated to providing a platform for developing integrated tools. throughout the history of eclipse the development team was successful in hitting projected delivery dates with precision and quality. this isn't possible without a team strongly committed to ship quality software. how is this really done? how does eclipse achieve quality and just-in-time delivery?this talk sheds light on the key practices of the eclipse development process - from the development mantras "always beta", "milestones first", "api first", and "performance first" to practices such as ensuring quality through multiple feedback loops. erich will reflect on proven practices for managing a large project performed by geographically dispersed teams and open source contributors in a highly competitive market. most of these practices have evolved in the open source project, but they are equally applicable to closed source projects and will help to improve quality, timeliness and reduce development stress in both types of environments.
automatic discovery of api-level exploits. we argue that finding vulnerabilities in software components is different from finding exploits against them. exploits that compromise security often use several low-level details of the component, such as layouts of stack frames. existing software analysis tools, while effective at identifying vulnerabilities, fail to model low-level details, and are hence unsuitable for exploit-finding.we study the issues involved in exploit-finding by considering application programming interface (api) level exploits. a software component is vulnerable to an api-level exploit if its security can be compromised by invoking a sequence of api operations allowed by the component. we present a framework to model low-level details of apis, and develop an automatic technique based on bounded, infinite-state model checking to discover api-level exploits.we present two instantiations of this framework. we show that format-string exploits can be modeled as api-level exploits, and demonstrate our technique by finding exploits against vulnerabilities in widely-used software. we also use the framework to model a cryptographic-key management api (the ibm cca) and demonstrate a tool that identifies a previously known exploit.
a specification matching based approach to reverse engineering. specification matching is a technique that has been used to retrieve reusable components from reuse libraries. the relationship between a query specification and a library specification is typically based on refinement, where a library specification matches a query specification if the library specification is more detailed than the query specification. reverse engineering is a process of analyzing components and component interrelationships in order to construct descriptions of a system at a higher level of abstraction. in this paper, we define the concept of an abstraction match as a basis for reverse engineering and show how the abstraction match can be used to facilitate a process for generalizing specifications. finally, we apply the specification generalization technique to a portion of a nasa jpl ground-based mission control system for unmanned flight systems.
an approach to architectural analysis of product lines. this paper addresses the issue of how to perform architectural analysis on an existing product line architecture. the con tribution of the paper is to identify and demonstrate a repeatable product line architecture analysis process. the approach defines a &ldquo;good&rdquo; product line architecture in terms of those quality attributes required by the particular product line under development. it then analyzes the architecture against these criteria by both manual and tool-supported methods. the phased approach described in this paper provides a structured analysis of an existing product line architecture using (1) formal specification of the high-level architecture, (2) manual analysis of scenarios to exercise the architecture's support for required variabilities, and (3) model checking of critical behaviors at the architectural level that are required for all systems in the product line. results of an application to a software product line of spaceborne telescopes are used to explain and evaluate the approach.
experiences on defining and evaluating an adapted review process. this paper presents our experiences with the introduction of a review process for software requirements documents in a development project of the passenger car development business unit (pcd) of daimlerchrylser ag. as software quality management and quality assurance must be carefully integrated into existing company processes or business cultures, we had to substantially adapt the review process to the specific needs of the above project and its context characteristics. the chief difference to the traditional procedure for conducting reviews as, for example, set out in [1] or [2] is that our review process has a strong workshop character with an emphasis on one of the most crucial success factors for reviews: sufficient time for the individual preparation of the reviewers. we also describe the phase of analyzing the effort and defect data captured with respect to cost benefit aspects and the quality of the reviewed documents in relation to each other.
software engineering for large-scale multi-agent systems - selmas'05. software is becoming present in every aspect of our lives, pushing us inevitably towards a world of distributed, context-aware computing systems. selmas'05, "software everywhere - context-aware agents", was built on the success of precedent selmas workshops, but with a special emphasis on the impact of the agent technology in the development of large context-aware systems. selmas has a track record of bringing together researchers and practitioners with a variety of perspectives in order to engage in lively discussion and debate. a particular interest of this workshop was to understand those issues in the agent technology that make it difficult and/or improve the production of context-aware systems.
the smart approach for software process engineering. describes a methodology for software process engineering and an environment, smart, that supports it. smart supports a process life-cycle that includes the modeling, analysis, and execution of software processes. smart's process monitoring capabilities can be used to provide feedback from the process execution to the process model. smart represents the integration of three separately developed process mechanisms, and it uses two modeling formalisms (object-oriented data representation and imperative-style programming language) to bridge the gap between process modeling, analysis, and execution. smart demonstrates the meta-environment concept, using a process modeling formalism as input specification to a generator that produces process-centered software engineering environments (psees). furthermore, smart supports a team-oriented approach for process modeling, analysis, and execution
software architecture: practice, potential, and pitfalls. whatever the long-term impact of software architecture may turn out to be, an appropriate starting point is a concrete appraisal of the current state of the practice in the use of software architecture. it is the purpose of the article to take a step in this direction. it provides concrete examples of what is now possible when architectural principles are applied to industrial problems in systematic ways, considers the potential impact of software architecture over the next few years, and suggests steps that should be taken to bring this about