waashk/dblp huggingface dataset:
introducing a software design language. this paper introduces software design language sdl-1, which is designed to serve as a design tool for the software engineer. in order to achieve this objective, some novel language constructs have been conceived. a sdl-1 design specification is a top-down 3-level structure. special keywords (called structure, storage, and control keywords) are employed and placed to clearly indicate the design structure. these keywords are highly suggestive and descriptive to the nature of data structure and control constructs. sdl-1 requires the declaration of all procedure names and the description of their functions at the very beginning of the design specifications. it requires also the declaration of all data storages and all switches, it describes the procedure structure, the data-storage reference structure, and the switch structure. all procedures are defined with single-in-single-out control constructs with one exception. the first procedure is the main procedure. no procedure definition is permitted within a procedure definition. the writing style and design practice are also a necessary part in using the language for a software design. in short, a sdl design specification is a structured design whose data storage is descriptive and direct, whose procedure structure describes the procedure calling and returning relationship, whose switch structure and reference structure indicate the inter-procedure communication, and whose control flow in a procedure is structured and readily observable.
modeling and implementing software architecture with acme and archjava. we demonstrate a tool to incrementally synchronize an acme architectural model described in the acme architectural description language (adl) with an implementation in archjava, an extension of the java programming language that includes explicit architectural modeling constructs.
the design of whole-program analysis tools. building efficient tools for understanding large software systems is difficult. many existing program understanding tools build control flow and data flow representations of the program a priori, and therefore may require prohibitive space and time when analyzing large systems. since much of these representations may be unused during an analysis, we construct representations on demand, not in advance. furthermore, some representations, such as the abstract syntax tree, may be used infrequently during an analysis. we discard these representations and recompute them as needed, reducing the overall space required. finally, we permit the user to selectively trade off time for precision and to customize the termination of these costly analyses in order to provide finer user control. we revised the traditional software architecture for compilers to provide these features without unnecessarily complicating the analyses themselves. these techniques have been successfully applied in the design of a program slicer for the comprehensive health care system (chcs), a million line hospital management system written in the mumps programming language.
software engineering 2004: acm/ieee-cs guidelines for undergraduate programs in software engineering. this paper is an overview of software engineering 2004, the software engineering volume of the computing curricula 2001 project. we briefly describe the contents of the volume, the process used in developing the volume's guidelines, and how we expect the volume to be used in practice.
inferring templates from spreadsheets. we present a study investigating the performance of a system for automatically inferring spreadsheet templates. these templates allow users to safely edit spreadsheets, that is, certain kinds of errors such as range, reference, and type errors can be provably prevented. since the inference of templates is inherently ambiguous, such a study is required to demonstrate the effectiveness of any such automatic system. the study results show that the system considered performs significantly better than subjects with intermediate to expert level programming expertise. these results are important because the translation of the huge body of existing spreadsheets into a system based on safety-guaranteeing templates cannot be performed without automatic support. we also carried out post-hoc analyses of the video recordings of the subjects' interactions with the spreadsheets and found that although expert-level subjects needed less time and developed more accurate templates than less experienced subjects, they did not inspect fewer cells in the spreadsheet. %and found that expert-level subjects spend less time and inspect fewer cells in the spreadsheet and develop more accurate templates than subjects with less experience.
accelerating software development through collaboration. in early 1999, va software launched a project to understand how the internet development community had been able to produce software such as linux, apache and samba that was generally developed faster and with higher quality than comparable commercially available alternatives [1,2,3,20]. our goal was simple: determine how to make more software development projects successful.we discovered that successful internet community projects employed a number of practices that were not well characterized by traditional software engineering methodologies. we now refer to those practices as collaborative software development or csd. late in 1999 we developed the sourceforge platform to make it easy for even small software development projects to employ those practices, and in november of 1999 launched the sourceforge.net web site based on the sourceforge platform.the site was an overwhelming success, and in less than two years, grew to support more than 27,000 software development projects and over a quarter million software developers worldwide. sourceforge.net affords us an unequaled test bed for understanding csd. in response to demand from companies seeking to enable csd within their organizations, we announced a commercial version of the sourceforge platform, sourceforge enterprise edition, in august 2001.this paper describes the principles of csd, the software development pain points those principles address, and our experience enabling csd with the sourceforge platform.
commitment development in software process improvement: critical misconceptions. it has been well established in the software process improvement (spi) literature and practice that without commitment from all organizational levels to spi the initiative will most likely fail or the results are not far reaching. commitment construct is explored and three forms of commitment are introduced: affective, continuance and normative commitment. analysis shows that current models of commitment development lack scientific validity and are based on four misconceptions: (1) the assumption of linearity of the human cognitive processes (i.e., commitment in this case), (2) the controllability of this process, (3) the notion of singular commitment construct, and (4) the sole utility perspective on the commitment phenomenon. implications of these findings for spi research and practice are discussed.
validating the unit correctness of spreadsheet programs. financial companies, engineering firms and even scientistscreate increasingly larger spreadsheets and spreadsheetprograms. the creators of large spreadsheets makeerrors and must track them down. one common class oferrors concerns unit errors, because spreadsheets often employformulas with physical or monetary units.in this paper, we describe xelda, our tool for unit checkingexcel spreadsheets. the tool highlights cells if theirformulas process values with incorrect units and if derivedunits clash with unit annotations. in addition, it draws arrowsto the sources of the formulas for debugging. the toolis sensitive to many of the intricacies of excel spreadsheetsincluding tables, matrices, and even circular references.using xelda, we have detected errors in some publishedscientific spreadsheets.
addressing software dependability with statistical and machine learning techniques. our ability to design and deploy large complex systems is outpacing our ability to understand their behavior. how do we detect and recover from "heisenbugs," which account for up to 40% of failures in complex internet systems, without extensive application-specific coding? which users were affected, and for how long? how do we diagnose and correct problems caused by configuration errors or operator errors? although these problems are posed at a high level of abstraction, all we can usually measure directly are low-level behaviors---analogous to driving a car while looking through a magnifying glass. machine learning can bridge this gap using techniques that learn "baseline" models automatically or semi-automatically, allowing the characterization and monitoring of systems whose structure is not well understood a priori. i'll discuss initial successes and future challenges in using machine learning for failure detection anbd diagnosis, configuration troubleshooting, attribution (which low-level properties appear to be correlated with an observed high-level effect such as decreased performance), and failure forecasting.
new directions on agile methods: a comparative analysis. agile software development methods have caught the attention of software engineers and researchers worldwide. scientific research is yet scarce. this paper reports results from a study, which aims to organize, analyze and make sense out of the dispersed field of agile software development methods. the comparative analysis is performed using the method's life-cycle coverage, project management support, type of practical guidance, fitness-for-use and empirical evidence as the analytical lenses. the results show that agile software development methods, without rationalization, cover certain/different phases of the software development life-cycle and most of the them do not offer adequate support for project management. yet, many methods still attempt to strive for universal solutions (as opposed to situation appropriate) and the empirical evidence is still very limited based on the results, new directions are suggested in principal it is suggested to place emphasis on methodological quality -- not method quantity.
improving software security with a c pointer analysis. this paper presents a context-sensitive, inclusion-based, field-sensitive points-to analysis for c and uses the analysis to detect and prevent security vulnerabilities in programs. in addition to a conservative analysis, we propose an optimistic analysis that assumes a more restricted c semantics that reflects common c usage to increase the precision of the analysis.this paper uses the proposed pointer alias analyses to infer the types of variables in c programs and shows that most c variables are used in a manner consistent with their declared types. we show that pointer analysis can be used to reduce the overhead of a dynamic string-buffer overflow detector by 30% to 100% among applications with significant overheads. finally, using pointer analysis, we statically found six format string vulnerabilities in two of the 12 programs we analyzed.
formal methods in industry: achievements, problems, future. two real projects using the b formal method are quickly presented. they show how some important parts of complex systems can be developed in such a way that the outcome is "correct by construction". a number of factors are then analyzed relating the pros, the cons, and the difficulties in applying this approach in industry.
the graft-host method for design change. the authors report on the graft-host (g-h) method, a practical method for changing designs incrementally by means of graft-and-repair steps. the method is not automated. computational support to designers applying g-h comes in the form of tools to help them reuse design information and manage databases of constraints. the method derives its strength from the reuse of analysis and design information. some key features of g-h are: evaluation of grafts and host systems at the analysis and design level by reusing information from technology books (g. arango et al., 1993); reuse and adaptation of software components driven by analysis and design considerations; evaluation of designs along multiple design dimensions; and composition of change rationales as formal explanations of change propagation and change tradeoff analyses. the g-h method was validated on the redesign of industrial products in the context of technology books
experimental results on the paging behavior of numerical programs. traces of numerical programs are used to examine their behavior in a paged virtual memory system. the working set policy is used for the replacement algorithm. it is found that the behavior of such programs is different from the behavior of other types of programs like compilers and system programs. these differences are most significant in the lifetime curves and the space-time cost curves. all programs examined showed ill-behavior. moreover, the space-time costs of executing these programs are very sensitive to the choice of the control parmater, the window size. our measurements show that approximations based on the common practice of using virtual time instead of real time in generating statistics are often inaccurate. the &ldquo;primary knee criterion&rdquo; of optimizing the space-time cost did not hold for some programs. the parameter-real memory and the real memory-fault rate anomalies show significantly in all but one of the seventeen programs examined.
opsis: a view mechanism for software processes which supports their evolution and reuse. the paper describes opsis, a view mechanism applied to graph based process modelling languages of type petri net. a view is a sub model which can be mechanistically constructed from another model by application of a perspective which: identifies all parts of the original model that are contained in the submodel; identifies and transforms all parts that constitute the interface to other sub models; adds new link relations to describe the behaviour of the sub model in interaction with the other sub models. sub models are more easy to grasp and can be limited in scope to some well defined aspects of a global model, such as the view point ofa single role player. composition of sub models is achieved through a merge operation on interface elements of sub models. the intended use of opsis is: 1) process evolution-changes can be localised to certain views, which largely reduces the complexity of applying change; and 2) process reuse-libraries can contain reusable fragments of type view that can be combined using the composition operators.
optimization of software development. for many companies, including leaders in software development, software is becoming an increasingly critical competitive factor. for example, at siemens, sixty percent of our business is strongly influenced by software and approximately fifty percent of all siemens patents are software related. with more than 30,000 software developers worldwide and an expenditure of more than 3 billion euros, siemens is playing in the 'champions league' of the world's leading software companies. but this fact is not well known because most of the software developed at siemens is embedded. it's embedded in the products and solutions sold to customers, such as medical devices, automation controls, trains, automotive components, and even power plants. yet a major part of the functionality of these products and solutions is defined by software.because of the high cost of developing software, and because of its extraordinarily high business impact, optimizing the software development process has become a top priority at siemens. simplifying, standardizing and stabilizing development processes and measuring progress according to the cmmi of the software engineering institute, making better use of existing synergy potentials, for example by using cross-divisional software platforms and architectures, and reducing costs by making structural changes, such as offshoring software development to low-wage countries and using the skills of different cultures, especially in rapidly-developing asian markets.the three levers will be described in detail and examples will be provided. the presentation will emphasize the early phases of software development, particularly with reference to requirements engineering and the importance of functional and non-functional requirements. a simple metrics system to measure success in software development will be presented. the siemens software initiative, a company-wide program specializing on software engineering and management at siemens will also be described.
analyzing partially-implemented real-time systems. we propose a method for analyzing partially-implemented real-time systems. here we consider real-time concurrent systems for which some components are implemented in ada and some are partially specified using regular expressions and graphical interval logic (gil), a real-time temporal logic. we show how to construct models of the partially-implemented systems that account for such properties as run-time overhead and scheduling of processes, yet support tractable analysis of nontrivial programs. the approach can be fully automated, and we illustrate it by analyzing a small example.
extending the discipline: how software can help or hinder human decision making (and vice-versa). developments in computing offer experts in many fields specialised support for decision making under uncertainty. however, the impact of these technologies remains controversial. in particular, it is not clear how advice of variable quality from a computer may affect human decision makers. here i review research showing strikingly diverse effects of computer support on expert decision-making. decisions support can both systematically improve or damaged the performance of decision makers in subtle ways depending on the decision maker's skills, variation in the difficulty of individual decisions and the reliability of advice from the support tool.in clinical trials decision support technologies are often assessed in terms of their average effects. however this methodology overlooks the possibility of differential effects on decisions of varying difficulty, on decision makers of varying competence, of computer advice of varying accuracy and of possible interactions among these variables. research that has teased apart aggregated clinical trial data to investigate these possibilities has discovered that computer support was less useful for - and sometimes hindered - professional experts who were relatively good at difficult decisions without support; at the same time the same computer support tool helped those experts who were less good at relatively easy decisions without support. moreover, inappropriate advice from the support tool could bias decision makers' decisions and, predictably, depending on the type of case, improve or harm the decisions.
design and verification of communication procedures: a bottom-up approach. the verification of functional specifications is performed by means of a formal model, based upon petri nets. a so-called "reduction" operation is introduced to handle the concept of abstraction. a bottom-up approach is developped in the case of communication between two processors. the definition of software modules is emphasized.
human capacities in the software process: empiric validation. in this paper an empiric validation of a person to role allocation process is presented. in this process the allocation of persons to fulfill roles is made according to the capacities that the persons possess and those required by the roles in the software process. a set of experiments are carried out dealing with the development of the initiation, planning and estimation process, domain study process, requirements analysis process and design process of eight projects. it was proved that the estimated time deviation, as well as the errors found in the technical reviews of requirements specification, were less when the persons fulfilling the roles of planning engineer, domain analyst, requirements specificator and designer were allocated, according to the proposed process, considering the set of critical human capacities.
specification and verification of distributed systems using prolog interpreded petri nets. this paper presents a formal description technique for distributed systems. the basic choices concern petri nets as a modeling tool and prolog as a programming environment. the key elements of the introduced approach are a symbolic interpreter for predicate transition nets, and a technique for interfacing concurrent processes. several illustrative examples are provided.
an interactive tool for program manipulation. an interactive system for understanding programs has been designed. this system provides informations about control structure and data flow. it also performs powerful semantic transformations that are checked for validity. the system relies on previously implemented algorithms that apply to a graph representation of programs.
interactive software development tool: isdt. this paper describes an interactive software development tool(isdt),which supports the detailed system design and the manufacture phase in the business application system development. the isdt is based on standardized technology and engineering for programming support (steps), experience gained is complied, and new program development support techniques are adopted. the isdt user will be able to design programs interactively while sitting at a display terminal. isdt manages specifications stored in a database and automatically generates cobol programs and documents as required. this paper discusses business application program characteristics at first. then it is shown how the development support system should be handled. next, isdt functions are explained with plenty of figures.
towards a distributed software architecture evaluation process: a preliminary assessment. scenario-based methods for evaluating software architecture require a large number of stakeholders to be collocated for evaluation sessions. collocating stakeholders is often an expensive exercise. we have proposed a framework for distributed evaluation process. we present the proposed framework and initial results of a controlled experiment that we ran to assess the effectiveness of the proposed idea.
developing and deploying software engineering courseware in an adaptable curriculum framework. we describe an effort to design an adaptable framework for teaching and learning in software engineering. we are developing a repository of asynchronous, multimedia courseware that facilitates the rapid incorporation of new advances in research and technology, enables courses to be tailored to individual student needs and interests, leverages innovations in educational technology and encourages innovation in teaching and in student learning. our emphasis is on developing composable multi-level &ldquo;knowledge and topic units&rdquo; (ku/tus) that can be employed to tailor course content and depth to fit the needs of a diverse student population. we have developed &ldquo;live&rdquo; and on-line course material for ku/tus in software engineering and taught courses using this material. the framework was deployed in three software engineering courses (previously taught concurrently) and provides quite different learning environments for the students in each course and, to some extent, tailors the courses to individual students within the classes based on their skills, objectives and backgrounds. we describe efforts at formative evaluation. student satisfaction is high and available measures of success, e.g., student performance, have improved markedly. we also describe a project now beginning to build on this prototype that will be accompanied by more extensive formative and summative evaluation.