waashk/dblp huggingface dataset:
a tool for analyzing and detecting malicious mobile code. we present a tool for analysis and detection of malicious mobile code such as computer viruses and internet worms based on the combined use of code simulation, static code analysis, and os execution emulation. unlike traditional anti-virus methods, the tool directly inspects the code and identifies commonly found malicious behaviors such as mass mailing, self duplication, and registry overwrite without relying on ``pattern files'' that contain ``signatures'' of previously captured samples. the prohibited behaviors are defined separately as security policies at the level of api library function calls in a state-transition like language. the tool also features data flow analysis based on static single assignment forms, which are useful in tracing various values stored in registers and memory locations. the current tool targets at win32 binary programs on intel ia32 architectures and can detect most email virusesslash worms that had spread in the wild in recent years.
investigating and improving a cots-based software development. the work described in this paper is an investigation of cots-based software development within a particular nasa environment, with an emphasis on the processes used. fifteen projects using a cots-based approach were studied and their actual process was documented. this process is evaluated to identify essential differences in comparison to traditional software development. the main differences, and the activities for which projects require more guidance, are requirements definition and cots selection, high level design, integration and testing. starting from these empirical observations, a new process and guidelines for cots-based development are developed and briefly presented. the new process is currently under experimentation.
is software education narrow-minded? a position paper. the content of computer science and software engineering courses needs to be examined so that students are better prepared to cope with the challenges of a rapidly changing software industry.
an incremental project plan: introducing cleanroom method and object-oriented development method. introducing new technologies into a software development process or project often produces both good and bad effects. if it is well planned it will improve both productivity and quality. we present an incremental development process planning approach (idpa) which uses the idea of technical dependency-based assessment of the project planning for a small and stable development team shifting slowly but steadily to a new software paradigm that fits the traditional development process. the project plan was a well-connected set of incremental fragments of improvements with the introduction of new technologies or methods to the previous plans. idpa is a method of assessing each technology or method to be decomposed and scheduled according to the technical dependency at the time of introduction. we also present a case study applying this idea to a real development project, in which object-oriented technology and the cleanroom method were introduced, and present the results of its evaluation
software engineering for distributed applications: the design project. the design project combines a set of new approaches to software engineering for distributed applications. distributed applications may thereby consist of a large, varying number of interacting processes. specific problems encountered with the development of such distributed applications are not suitably reflected by known programming languages and software engineering environments. the design system in its current version integrates consistent approaches specifically suited for distributed application development. these approaches pertain to the areas `language support`, `performance prediction/rapid prototyping`, and `project support environment`. most parts of the design system have been implemented and successfully applied to first sample distributed applications.
applying algorithm animation techniques for program tracing, debugging, and understanding. algorithm animation presents a dynamic visualization of an algorithm or program. this work seeks to bridge the two domains of data structure display and algorithm animation. the application-specific nature of algorithm animation views could be a valuable debugging aid for software developers. a system called lens was developed that allows programmers to rapidly develop animations of their programs. lens supports application-specific semantic program views as seen in many algorithm animation systems, but does not require graphics programming. lens is integrated with a system debugger to support iterative testing and refinement. the authors describe the conceptual model on which lens is based, illustrate how program animations are built with lens, and outline some of the implementation challenges the system presents
rigi - a system for programming-in-the-large. this paper describes rigi, a model and a tool for programming-in-the-large. rigi uses a graph model and abstraction mechanisms to structure and represent the information accumulated during the development process. the objects and relationships of the graph model represent system components and their dependencies. the objects can be arranged in aggregation and generalization hierarchies. the rigi editor assists the designers, programmers, integrators, and maintainers in defining, manipulating, exploring, and understanding, the structure of large, integrated, evolving software systems. rigi was designed to address three of the most difficult problems in the area of programming-in-the-large: the mastery of the structural complexity of large software systems, the effective presentation of development information, and the definition of procedures for checking and maintaining the completeness, consistency, and traceability of system descriptions. thus, the major objective of rigi is to effectively represent and manipulate the building blocks of a software system and their myriad dependencies, thereby aiding the development phases of the project.
case study: extreme programming in a university environment. extreme programming (xp) is a new and controversial software process for small teams. a practical training course at the university of karlsruhe led to the following observations about the key practices of xp. first, it is unclear how to reap the potential benefits of pair programming, although pair programming produces high quality code. second, designing in small increments appears problematic but ensures rapid feedback about the code. third, while automated testing is helpful, writing test cases before coding is a challenge. and last, it is difficult to implement xp without coaching. this paper also provides some guidelines for those starting out with xp.
requirement specification description system in japanese language - jisdos. the syntax of a requirement specification description language should be similar to the language in which the users think. we have developed a system called jisdos in which a user can describe his requirements using a formalized japanese language. the description language, called jpsl, is basically a translation of psl with the syntactic characteristics of the japanese language. pre- and post-processors are added to psa for transformations of jpsl descriptions into psl and conversely to psl reports into jpsl, so that no modification was performed on psl/psa. a user inputs jpsl statements either in katakana (square phonetic characters) or romaji (english alphabetic representation of japanese characters), and he can receive various kinds of reports in hiragana (curved phonetic characters) and kanji (chinese characters). it is concluded that jpsl has a high degree of readability and descriptive power in writing requirement specifications.
algorithm development in the mobile environment. mobility is emerging as a new research field with its own characteristic problems, models, and algorithms. fixed networks are commonplace but the challenges of mobility such as the transient nature of connections, reduced bandwidth, and limited processing power have made incorporating mobility into this existing environment challenging. our contribution to the rapid integration of mobility is the design and development of algorithms in the mobile environment which will serve as a foundation for mobile applications. in this paper, we describe two models for mobility, outline the challenges of each environment, and provide approaches to algorithm development within each model.
separating features in source code: an exploratory study. most software systems are inflexible. reconfiguring a system's modules to add or to delete a feature requires substantial effort. this inflexibility increases the costs of building variants of a system, amongst other problems. new languages and tools that are being developed to provide additional support for separating concerns show promise to help address this problem. however, applying these mechanisms requires determining how to enable a feature to be separated from the codebase. in this paper, we investigate this problem through an exploratory study conducted in the context of two existing systems: gnu.regexp and jftpd. the study consisted of applying three different separation of concern mechanisms&mdash;hyper/j,tm aspectj,tm and a lightweight, lexically-based approach&mdash;to separate features in the two packages. in this paper, we report on the study, providing contributions in two areas. first, we characterize the effect different mechanisms had on the structure of the codebase. second, we characterize the restructuring process required to perform the separations. these characterizations can help researchers to elucidate how the mechanisms may be best used, tool developers to design support to aid the separation process, and early adopters to apply the techniques.
an empirical study of static call graph extractors. informally, a call graph represents calls between entities in a given program. the call graphs that compilers compute to determine the applicability of an optimization must typically be conservative: a call may be omitted only if it can never occur an any execution of the program. numerous software engineering tools also extract call graphs, with the expectation that they will help software engineers increase their understanding of a program. the requirements placed on software engineering tools when computing call graphs are typically more related than for compilers. for example, some false negatives-calls that can in fact take place in some execution of the program, but which are omitted from the call graph-may be acceptable, depending on the understanding task at hand. in this paper we empirically show a consequence of this spectrum of requirements by comparing the c call graphs extracted from three software systems (mapmaker, mosaic, and gee) by five extraction tools (cflow, cia, field, mk-functmap, and rigiparse). a quantitative analysis of the call graphs extracted for each system shows considerable variation, a result that is counterintuitive to many experienced software engineers. a qualitative analysis of these results reveals a number of reasons for this variation: differing treatments of macros, function pointers, input formats, etc. we describe and discuss the study, sketch the design space, and discuss the impact of our study on practitioners, tool developers, and researchers.
meeting the challenges of web application development: the web engineering approach. the web has very rapidly become central to many applications in diverse areas. as our reliance on web-based applications continues to increase and the web systems supporting these applications become more complex, there is growing concern about the manner in which the web-based systems/applications are created and their quality, integrity and maintainability. the development of web-based systems has generally been ad hoc, resulting in poor quality and maintainability. in the recent times, there have been many failures of web applications due to a variety of problems and causes. the way the developers address these problems is critical to deploying successful large-scale web applications.this tutorial addresses these issues and offers a holistic approach to managing the complexity of development of web-based systems and web applications. it highlights the various real-world issues, challenges and considerations in development of large web applications, compared to traditional software development, and recommends the web engineering approach that web/software developers could follow.web engineering deals with systematic, disciplined and quantifiable approaches to development, operation, and maintenance of web-based systems and applications [1-9]. it embodies engineering principles and practices to web application and web site development and draws on software engineering and a number of contributing disciplines.specifically, the tutorial aims to:&bull; highlight the problems, complexity and challenges of web application development relative to software development&bull; offer a holistic approach to development of web applications&bull; present web development methodologies and processes&bull; address the issues of scalability, maintainability, usability, configuration management and other non-technical aspects&bull; recommend suitable web testing and quality assurance approaches&bull; discuss project management issues specific to web developmentthis tutorial is specifically targeted to address the needs of a growing community of software practitioners, web application developers, project managers it and business professionals, ecommerce system implementers, academics, researchers and students.
a logarithmic poisson execution time model for software reliability measurement. a new software reliability model is developed that predicts expected failures (and hence related reliability quantities) as well or better than existing software reliability models, and is simpler than any of the models that approach it in predictive validity. the model incorporates both execution time and calendar time components, each of which is derived. the model is evaluated, using actual data, and compared with other models.
designing an economic-driven evaluation framework for process-oriented software technologies. during the last decade there has been a dramatic increase in the number of paradigms, standards and tools that can be used to realize process-oriented information systems. a major problem neglected in software engineering research so far has been the systematic determination of costs, benefits, and risks that are related to the use of these process-oriented software engineering methods and technologies. this task is quite difficult as the added value is influenced by many drivers. this paper sketches an economic-driven evaluation methodology to analyze costs, benefits, and risks of process-oriented software technologies and corresponding projects. we introduce an evaluation meta model and sketch a formalism to describe economic-driven evaluation scenarios.
exploiting adls to specify architectural styles induced by middleware infrastructures. architecture definition languages (adls) enable the formalization of the architecture of software systems and the execution of preliminary analyses on them. these analyses aim at supporting the identification and solution of design problems in the early stages of software development. we have used adls to describe middleware-induced architectural styles. these styles describe the assumptions and constraints that middleware infrastructures impose on the architecture of systems. our work originates from the belief that the explicit representation of these styles at the architectural level can guide designers in the definition of an architecture compliant with a pre-selected middleware infrastructure, or, conversely can support designers in the identification of the most suitable middleware infrastructure for a specific architecture. in this paper we provide an evaluation of adls as to their suitability for defining middleware-induced architectural styles. we identify new requirements for adls, and we highlight the importance of existing capabilities. although our experimentation starts from an attempt to solve a specific problem, the results we have obtained provide general lessons about adls, learned from defining the architecture of existing, complex, distributed, running systems.
use of software engineering tools in japan. this paper describes the current status of software engineering tool usage by the japanese software industry based upon statistics obtained from several surveys conducted by the japan information services industry association and related organizations. it also analyzes various social and technical factors behind these statistics. practical application of various software engineering tools in japan currently seems to remain at a very low level. some concluding comments will be made suggesting directions for possible future improvements.
toward a software testing and reliability early warning metric suite. the field reliability is measured too late for affordablyguiding corrective action to improve the quality of thesoftware. software developers can benefit from an earlywarning of their reliability while they can still affordablyreact. this early warning can be built from a collection ofinternal metrics. an internal metric, such as the numberof lines of code, is a measure derived from the productitself [15]. an external measure is a measure of a productderived from assessment of the behavior of the system[15]. for example, the number of defects found in test isan external measure. the iso/iec standard [15] statesthat "[i]nternal metrics are of little value unless there isevidence that they are related to external quality."internal metrics can be collected in-process and moreeasily than external metrics. additionally, internalmetrics have been shown to be useful as early indicatorsof externally-visible product quality [1]. for these earlyindicators to be meaningful, they must be related (in astatistically significant and stable way) to the fieldquality/reliability of the product. the validation of suchmetrics requires the convincing demonstration that (1) themetric measures what it purports to measure and (2) themetric is associated with an important external metric,such as field reliability, maintainability, or fault-proneness[12].software metrics have been used as indicators ofsoftware quality [1, 19-21, 23] and fault proneness [8-10,24]. there is a growing body of empirical results thatsupports the theoretical validity of the use of higher-orderearly metrics, such as oo metrics [1] defined bychidamber-kemerer (ck) [6] and the mood [5] oometric suites as predictors of field quality. however,general validity of these metrics (which are oftenunrelated to the actual operational profile of the product)is still open to criticism [7].
use of relative code churn measures to predict system defect density. software systems evolve over time due to changes in requirements, optimization of code, fixes for security and reliability bugs etc. code churn, which measures the changes made to a component over a period of time, quantifies the extent of this change. we present a technique for early prediction of system defect density using a set of relative code churn measures that relate the amount of churn to other variables such as component size and the temporal extent of churn.using statistical regression models, we show that while absolute measures of code churn are poor predictors of defect density, our set of relative measures of code churn is highly predictive of defect density. a case study performed on windows server 2003 indicates the validity of the relative code churn measures as early indicators of system defect density. furthermore, our code churn metric suite is able to discriminate between fault and not fault-prone binaries with an accuracy of 89.0 percent.
effective software architecture design: from global analysis to uml descriptions. it is now generally accepted that separating software architecture into multiple views can help in reducing complexity and in making sound decisions about design trade-offs. our four views are based on current practice; they are loosely coupled, and address different engineering concerns [1]. this tutorial will teach you how global analysis can improve your design, and how to use uml to describe these views. you will learn: (1) the purpose of having separate software architecture views, (2) the difference between using uml for software architecture and the use of uml for designing oo implementations, (3) how to apply global analysis to analyze factors that influence the architecture and to develop strategies that guide the design, (4) the importance of designing for anticipated change to produce more maintainable architectures, and (5) how to incorporate software architecture design in your software process. this tutorial is aimed at experienced software engineers, architects, and technical managers. it is assumed that participants know the basic uml diagrams. experience in developing models and software design is helpful.
static analysis tools as early indicators of pre-release defect density. during software development it is helpful to obtain early estimates of the defect density of software components. such estimates identify fault-prone areas of code requiring further testing. we present an empirical approach for the early prediction of pre-release defect density based on the defects found using static analysis tools. the defects identified by two different static analysis tools are used to fit and predict the actual pre-release defect density for windows server 2003. we show that there exists a strong positive correlation between the static analysis defect density and the pre-release defect density determined by testing. further, the predicted pre-release defect density and the actual pre-release defect density are strongly correlated at a high degree of statistical significance. discriminant analysis shows that the results of static analysis tools can be used to separate high and low quality components with an overall classification rate of 82.91%.
mining metrics to predict component failures. what is it that makes software fail? in an empirical study of the post-release defect history of five microsoft software systems, we found that failure-prone software entities are statistically correlated with code complexity measures. however, there is no single set of complexity metrics that could act as a universally best defect predictor. using principal component analysis on the code metrics, we built regression models that accurately predict the likelihood of post-release defects for new entities. the approach can easily be generalized to arbitrary projects; in particular, predictors obtained from one project can also be significant for new, similar projects.
reuse that pays. a company builds a software system capable of running a diesel engine in a week, and in one case over a weekend, as opposed to the full year that it used to take. another company builds one of its typical systems with 13 software engineers instead of the more than 100 it once required, and at the same time decreases the systems defect rate ten-fold. still another increases its software-intensive product offerings from four per year to 50 per year. imagine being able to use one person to integrate and test 1.5 million source lines of ada for a real-time command-and-control system onboard a ship, with safety-critical requirements? or increasing software productivity four-fold over three years, as another company has done? these organizations all achieved their results through strategic software reuse. we software people have been promising the benefits of reuse for decades. are we finally achieving a reuse strategy that lives up to its hype?