Search

This paper presents an efficient method for finding horseshoes in dynamical systems by using several simple results on topological horseshoes. In this method, a series of points from an attractor of a map (or a Poincaré map) are firstly computed. By dealing with the series, we can not only find the approximate location of each short unstable periodic orbit (UPO), but also learn the dynamics of almost every small neighborhood of the attractor under the map or the reverse map, which is very helpful for finding a horseshoe. The method is illustrated with the Hénon map and two other examples. Since it can be implemented with a computer software, it becomes easy to study the existence of chaos and topological entropy by virtue of topological horseshoe. [ABSTRACT FROM AUTHOR]

The article focuses on software technology development since 1984. It states that there are three clusters of software technologies: Basic technologies that contribute to broad trends and disciplines, Technology concepts and methodologies that combine the underlying methods that many different industries and products use, and consolidated technologies that are built on concepts and offer ready-to-use technical solutions. It comments on the impacts that technologies have had on industries and products, and mentions that some technologies have a longer maturation period than others, and provides as an example computer security and its integration into computer software architecture.

Abstract: CommUnity is a formal approach to Software Architecture with a strict separation of the computation, coordination, and distribution aspects. The approach is based on a parallel design language with state, which facilitates the specification of computations compared to the process calculi used by other formal approaches, and on category theory, which provides an intuitive yet precise graph-based semantics for the configuration of components and connectors. The CommUnity Workbench is being developed as a proof of concept of the CommUnity framework, providing a graphical integrated development environment to write components, draw configurations, and execute the resulting system. [Copyright &y& Elsevier]

Abstract: In this paper, we propose the use of Versioned Boxes, which keep a history of values, as the basis for language-level memory transactions. Unlike previous work on software transactional memory, in our proposal read-only transactions never conflict with any other concurrent transaction. This may improve significantly the concurrency on applications which have longer transactions and a high read/write ratio. Furthermore, we discuss how we can reduce transaction conflicts by delaying computations and re-executing only parts of a transaction in case of a conflict. We propose two language-level abstractions to support these strategies: the per-transaction boxes and the restartable transactions. Finally, we lay out the basis for a more generic model, which better supports fine-grained restartable transactions. The goal of this new model is to generalize the previous two abstractions to reduce conflicts. [Copyright &y& Elsevier]

Modern superscalar microprocessors need sizable register files to support a large number of in-flight instructions for exploiting instruction level parallelism (ILP). An alternative to building large register files is to use a smaller number of registers, but manage them more effectively. More efficient management of registers can also result in higher performance if the reduction of the register file size is not the goal. Traditional register file management mechanisms deallocate a physical register only when the next instruction writing to the same destination architectural register commits. In this paper, we propose several techniques for deallocating physical registers much earlier. Our designs rely on the use of a checkpointed register file (CRF), where a local shadow copy of each bitcell is used to temporarily save the values of the early deallocated registers should they be needed to recover from branch mispredictions or to reconstruct the precise state after exceptions or interrupts. The proposed techniques try to release registers as soon as possible and are more aggressive than the previously proposed schemes for early deallocation of registers. [ABSTRACT FROM AUTHOR]

We investigate the maximum increase in number of phrases that results from changing k consecutive symbols in a string x having length n parsed using an LZ'77-like algorithm. We consider a class of compression algorithms that partition a sequence into a collection y of nonoverlapping, variable-length phrases and encode them. Each phrase either is a singleton or matches a substring that starts to its left. We show that changing a single symbol of x in position i can yield an expansion that is of order O(n - i)2/3 as (n - i) → ∞. Our lower bound requires an alphabet size of O(n - i)1/3. We also show that changing k consecutive symbols starting from position i can yield an expansion having a similar but somewhat more involved form. The paper contains both analytically derived upper and lower bounds, and algorithms for numerically computing tighter bounds. While deriving the bounds, we provide a detailed analysis of how expansion can arise when changing consecutive symbols. This problem is motivated by management policies for computer systems, such as the IBM Memory eXpansion Technology (MXT) or the IBM iSeries compressed disks, that use LZ'77-like coding on small compression units, such as 1-4 kbyte, and store the compressed data in memory or on disk tracks. Here, when a change of a portion of the compression unit occurs, for example, an L2 cache line, or a 512-byte disk sector, the data is recompressed and potentially stored in a different location. Knowing the maximum expansion, rather than the average expansion, is an important factor for designing policies for allocation and management of memory or disk space. [ABSTRACT FROM AUTHOR]

The article suggests a new approach for multimethod implementation in C++. Several programming languages allow for multimethods, but C++ semantics do not. The proposed approach is based on recursive deferred dispatching. The multimethod implementation in C++ is discussed. The approach offers advantages that includes using a conventional multimethod syntax, it provides strong compile-time type safety and it decreases compilation time and ensures acceptable usability in real-world projects.

Abstract: The CMS collaboration is undertaking a big effort to define the analysis model and to develop software tools with the purpose of analysing several millions of simulated and real data events by a large number of people in many geographically distributed sites. From the computing point of view, one of the most complex issues when doing remote analysis is the data discovery and access. Some software tools were developed in order to move data, make them available to the full international community and validate them for the subsequent analysis. The batch analysis processing is performed with workload management tools developed on purpose, which are mainly responsible for the job preparation and the job submission. The job monitoring and the output management are implemented as the last part of the analysis chain. Grid tools provided by the LCG project are evaluated to gain access to the data and the resources by providing a user friendly interface to the physicists submitting the analysis jobs. An overview of the current implementation and of the interactions between the previous components of the CMS analysis system is presented in this work. [Copyright &y& Elsevier]

Abstract: A novel idea of utilizing only a computer to determine leaf area and perimeter was developed. The procedure is essentially computer software developed in Visual Basic that uses the computer monitor as the working surface to trace leaf outline and determines leaf area, perimeter, length, and width. Testing the software for effects of orientation, shape, and size of objects was carried out using opaque (paper) and transparent (polyvinyl chloride sheet) geometrical planar objects of known properties, such as regular polygons (three to eight sides), rectangles, and circles, developed by AutoCAD precision drawings. Direct leaf samples of mango, guava, egg plant, and castor representing varied shapes and sizes were used in measurements and results were also compared with existing graphical and digital planimetric methods. Component methods used in determination were area under the curve (AUC) and pixel count (PC), which was further divided into pixel count-inside (PCI) and pixel count-total (PCT). In general, geometrical objects area and perimeter measurements were found to be independent of orientation, shape, and size. However, perimeters of squares and rectangles obtained by PC methods were affected by object orientation. As the traced transparent samples do not offer appreciable improvement in estimations, opaque samples are recommended because they are convenient and directly used in measurements. Based on the performance with geometrical objects, the software was considered to handle objects of any shape and size equally well. Measurements with direct leaf samples compared well with the graphical (−4.62% to 7.81% deviation) and digital planimetric (−4.05% to 8.48% deviation) results, and variation was found to exist even among these basic methods possibly due to unavoidable manual tracing errors. Based on this study, PCI method for area and AUC method for perimeter determination are recommended. The developed software proved to be an accurate method for measurements of area and perimeter of leaves and other planar objects, such as maps; extends the application of personal computers to such measurements; and was less expensive as it does not require additional hardware. [Copyright &y& Elsevier]

The article explores the relationship and synergies between architecture-centric design and analysis methods and the Extreme Programming framework. The developers design the programming interface to match the tests' needs, and they write the code to match the tests and the interface. Architecture-centric methods can also add value to agile methods by emphasizing quality attributes and their role in shaping the architecture's design and by making it possible to adapt agile methods using a hybrid approach to handle larger, more complex systems.

The article discusses model-driven engineering (MDE) technologies offering a new approach to cover the inability of third-generation technologies and to facilitate the complexities of platforms and express domain concepts effectively. Efforts in the past, like the computer-aided software engineering which focused in improving software methods and tools, elevated the level of abstraction used to develop software. To improve the MDE technologies, there must be a combination of a domain-specific modeling languages and transformation engines and generators.

The article discusses ways to identify and capture early aspects in requirements and architecture activities related to computer softwares. Early aspects are concerns that crosscut an artifact's dominant decomposition or base modules derived from the dominant separation-of-concerns criterion, in the early stages of the software life cycle. Identifying and managing early aspects helps in improving modularity in the requirements and architecture design and to detect conflicting concerns early, thus resolving trade-offs. Besides, identifying aspects at one stage provides benefits downstream. Knowledge of requirements-level aspects helps architects in designing a better systems. Similarly, knowing architecture-level aspects helps produce a better implementation. Early aspects can measure development activities and many find their way into the code as traditional implementation aspects. Identifying early aspects across phases can increase the consistency of requirements and architecture designs with each other and provides a rationale and traceability for aspects across life-cycle activities. INSET: Dominant Decomposition in Early Software Development..

An understanding of how software is employed in the field can yield many opportunities for quality improvements. Profiling released software can provide such an understanding. However, profiling released software is difficult due to the potentially large number of deployed sites that must be profiled, the transparency requirements at a user's site, and the remote data collection and deployment management process. Researchers have recently proposed various approaches to tap into the opportunities offered by profiling deployed systems and overcome those challenges. Initial studies have illustrated the application of these approaches and have shown their feasibility. Still, the proposed approaches, and the tradeoffs between overhead, accuracy, and potential benefits for the testing activity have been barely quantified. This paper aims to overcome those limitations. Our analysis of 1,200 user sessions on a 155 KLOC deployed system substantiates the ability of field data to support test suite improvements, assesses the efficiency of profiling techniques for released software, and the effectiveness of testing efforts that leverage profiled field data. [ABSTRACT FROM AUTHOR]

Advance knowledge of which files in the next release of a large software system are most likely to contain the largest numbers of faults can be a very valuable asset. To accomplish this, a negative binomial regression model has been developed and used to predict the expected number of faults in each file of the next release of a system. The predictions are based on the code of the file in the current release, and fault and modification history of the file from previous releases. The model has been applied to two large industrial systems, one with a history of 17 consecutive quarterly releases over 4 years, and the other with nine releases over 2 years. The predictions were quite accurate: For each release of the two systems, the 20 percent of the files with the highest predicted number of faults contained between 71 percent and 92 percent of the faults that were actually detected, with the overall average being 83 percent. The same model was also used to predict which files of the first system were likely to have the highest fault densities (faults per KLOC). In this case, the 20 percent of the files with the highest predicted fault densities contained an average of 62 percent of the system's detected faults. However, the identified files contained a much smaller percentage of the code mass than the files selected to maximize the numbers of faults. The model was also used to make predictions from a much smaller input set that only contained fault data from integration testing and later. The prediction was again very accurate, identifying files that contained from 71 percent to 93 percent of the faults, with the average being 84 percent. Finally, a highly simplified version of the predictor selected files containing, on average, 73 percent and 74 percent of the faults for the two systems. [ABSTRACT FROM AUTHOR]

The article discusses about the computer software design. In this article, the author casts the software engineering process into the FBS framework. In the FBS framework, eight processes link a set of five elements. The framework aims to analyze how engineers design— that is, the processes and intermediate artifacts that are produced. A significant gap exists between analysis in software, which maps to synthesis in FBS, and analysis in other engineering disciplines, which one could call static software analysis— the techniques and tools one can apply to the design models and code to derive some of their properties, correctness included, without having to finish the code and run it. Evaluation is the assessment of the gap between expected behaviors and observed behaviors. Evaluation consists mostly of analyzing test results and static software analysis results, and partly of reviews and inspections. It corresponds to RUP's test discipline and some project management activities.

This article focuses on automated management of multicustomer code bases. For applications such as management information systems, customizing the code base to meet each new customer's needs can sometimes be unavoidable. Although good design can minimize the need for such code-level modifications, it can't eliminate it. Developing a management information system to be implemented for various clients with their own customizations can be difficult when the system suffers continuous modifications, whether introduced by the development team or the clients. Clients can add features to the main version or require the developers to incorporate into their implementation any new features they've added to the main project. Management information systems modifications, such as these, involve the application source code, database structure, application metadata, and external or internal utilities. Besides these issues, the typical problems associated with implementing applications still exist: platform independence, version incompatibility between the new application and other applications already installed in the client, and technology changes that affect the application code. Testing to check for errors in the management application is essential.

Several studies have revealed the fact that nearly two-thirds of all software process improvement (SPI) efforts have failed or have at least fallen short of expectations. Literature and practice have shown that commitment to SPI at all organizational levels is essential for the success of any SPI endeavor. A research model for studying the existence, development and interplay of SPI-related commitment is introduced in this paper. This study suggests that software organizations operate through strategic, operational and personal commitment nets. These nets consist of actors, drivers, concerns, actions, commitment, and outcomes. The commitment nets model is applied in a study of four industrial SPI initiatives. The results from two of these cases are reported here. The results show that SPI is driven through the formation and reformation of commitment nets. The contents of strategic, operational and personal commitment nets are laid out and implications are discussed. [ABSTRACT FROM AUTHOR]

Most of the software in regular use in businesses and organisations all over the world cannot he completely specified. It cannot he implemented, once and for all. Both the original implementation and the inevitable subsequent evolution (maintenance) are a continual learning experience driven, inter alia, by feedback from the results of the behaviour under execution of the software, as perceived by various stakeholders, by advances and growth in the user organisations and by adaptation to changes in the external world, both independent and as a result of installation and use of the software. Real world, termed type-E, software is essentially evolutionary in nature. The study of the processes of evolution of such software is of considerable interest, as is that of the domains that co-evolve with the software. After briefly discussing the meaning of the term evolution in the context of software, its technology, the software process and related domains, this paper describes some of the facets of the evolution phenomenon and implications to the evolution process as identified during many years of active interest in the topic. [ABSTRACT FROM AUTHOR]

Developments during the 1990s in the use of computer software for qualitative data analysis are surveyed. Salient trends are identified as are wider issues associated with software use. Also listed are some of the resources now available to potential and actual users of computer-assisted qualitative data analysis software (CAQDAS). [ABSTRACT FROM AUTHOR]

We develop a methodology for analyzing the performance and stability of a server that maintains a multilevel data structure to Service a set of access operations for (key, value) records. A subset of the operations executed by the server (e.g., insert and delete) require the multilevel data structure be reorganized so that the server can execute all subsequent requests efficiently. We study how often the server should carry out data reorganization (i.e., maintenance) to maximize its performance. If the server is frequently idle then there is no need to impose the reorganization overhead on the operation requests. The reorganization overhead may be completely eliminated by utilizing server-idling periods. If the server is frequently busy, then the reorganization overhead can be minimized by performing a complete reorganization only after the server has served a sufficient number of insert/delete operations so that the amortized cost per operation is small. Therefore, the issue of how often one should perform data reorganization to minimize the average service time depends not only on the multilevel data structure maintained by the server but also on the type and intensity of the system workload. The proposed methodology is exemplified with a two-level sorted file with deferred maintenance. The performance and stability results are compared with those of a single-level binary tree data structure with on-the-fly maintenance. It is shown that deferred maintenance of the two-level sorted file outperforms on-the-fly maintenance of the single-level binary tree in both open and closed systems. Furthermore, deferred maintenance can sustain higher workload intensities without risking system stability [ABSTRACT FROM AUTHOR]

Large and complex real-time systems can benefit significantly from a component-based development approach where new systems are constructed by composing reusable, documented and previously tested concurrent objects. However, reusing objects which execute under real-time constraints is problematic because application specific time and synchronization constraints are often embedded in the internals of these objects. The tight coupling of functionality and real-time constraints makes objects interdependent, and as a result difficult to reuse in another system. We propose a model which facilitates separate and modular specification of real-time constraints, and show how separation of real-time constraints and functional behavior is possible. We present our ideas using the Actor model to represent untimed objects, and the Real-time Synchronizers language to express real-time and synchronization constraints. We discuss specific mechanisms by which Real-time Synchronizers can govern the interaction and execution of untimed objects. We treat our model formally, and succinctly define what effect real-time constraints have on a set of concurrent objects. We briefly discuss how a middleware scheduling and event-dispatching service can use the synchronizers to execute the system. [ABSTRACT FROM AUTHOR]

An object based formal method for the development of real-time systems, called ATOM, is presented. The method is an integration of the real-time formal technique TAM (Temporal Agent Model) with an industry-strength structured methodology known as HRT-HOOD. ATOM is a systematic formal approach based on the refinement calculus. Within ATOM, a formal specification (or abstract description statement) contains Interval Temporal Logic (ITL) description of the timing, functional, and communication behavior of the proposed real-time system. This formal specification can be analyzed and then refined into concrete statements through successive applications of sound refinement laws. Both abstract and concrete statements are allowed to freely intermix. The semantics of the concrete statements in ATOM are defined denotationally in specification-oriented style using ITL. [ABSTRACT FROM AUTHOR]

The article focuses on opportunistic computer software development. It states that it is not economically viable for original equipment manufacturers to develop and supply all of the software needed for equipment. It suggests that industries need to employ combinations of commercial off-the-shelf software, embedded software, and open source software to meet demand. It states that opportunistic software development still requires programmers to utilize good engineering practices in order to deal with computer bugs and to help different computer codes work together. It mentions the need for computer programming education to train students in methods of analyzing software and utilizing it opportunistically.

The article focuses on computer programming requirements from 1984-2008. It states that requirement documents in the early 1980s were long, ambiguous, and full of inconsistencies. It mentions that requirements techniques have improved significantly by 2008, with training in requirements techniques available in University engineering courses and computer software that can document, manage, and analyze requirements. It comments on changes in software tools that support requirements work and mentions that computer-aided software engineering tools were the forerunners of modern requirements tools. It lists other requirements practices that have improved in 25 years, including tracing requirements, training people to be better requirements analysts, and identifying stakeholders in projects.

The article focuses on some factors that cause the failure of computer software. These factors break down into the categories of project management, project implementation and project metamanagement. Some of these factors are unarticulated project goals, inaccurate estimates of needed resources, badly defined systems requirements, sloppy development practices, poor communication among customers, developers and users, poor reporting of the project's status, unmanaged risks, stakeholder politics and commercial pressures.