Search

Software reuse can be defined as the process of creating software products from the existing ones rather than developing software from scratch. Thus, software reuse is normally proposed to increase software productivity and quality and leads to economic benefits. In this sense, the reuse of software requirements has received important attention because it provides a solid support to develop quality software through obtaining and reusing quality software requirements [i.e., software product line (SPL) approach used in large-sized software enterprises]. However, the small-sized enterprises-which represent up to 85 % of all software organizations in many countries around the world-cannot implement a SPL approach because it does not fit with the context, properties, and complexity of their software projects. Moreover, the software engineering community has not adequately explored a more proper approach in the context of small-sized software enterprises. The use of a software requirements catalog could be this proper approach. In this context, the aim of this paper was to introduce the requirements reuse model for software requirements catalog (RRMSRC). Also, a set of guidelines to perform the main activities defined for reusing functional requirements within small-sized software enterprises is provided. As evidence of its feasibility, RRMSRC has been used in an industrial context, and the obtained results and learned lessons are summarized. [ABSTRACT FROM AUTHOR]

This history of Informix is told from the founder's point of view and his personal experience. He talks about the Silicon Valley of the late 1970s, the "fire in the valley" days, and the feeling that history was going to be made and that computer scientists would be playing a major role in these changes. The relational database revolution, the flourishing success of the PC packaged software industry, and the Unix server victories are the backdrop for this story. Like all stories about a young company, it is about people and what drives entrepreneurs to take oversized chances and accept the risks involved. [ABSTRACT FROM PUBLISHER]

The article discusses the issues whether and when viral terms should be directly enforceable against downstream users. It is mentioned that the technical infrastructure that the Internet provides is not adequate and it is important that viral terms be widely enforceable. Discussed also are peer production of software, viral marketing, academic peer review and commenting. Courts and commentators have applied two different justifications to the enforcement of viral terms. It is stated that notice strategies and registration of viral terms would be infeasible and ineffectual. In addition, it is inferred that the Internet has the capacity to create more changes in the business and if some viral terms are enforceable, viral business methods can develop fully.

Abstract: We present a new software implementation to more efficiently compute the mutual information for all pairs of genes from gene expression microarrays. Computation of the mutual information is a necessary first step in various information theoretic approaches for reconstructing gene regulatory networks from microarray data. When the mutual information is estimated by kernel methods, computing the pairwise mutual information is quite time-consuming. Our implementation significantly reduces the computation time. For an example data set of 336 samples consisting of normal and malignant B-cells, with 9563 genes measured per sample, the current available software for ARACNE requires 142 hours to compute the mutual information for all gene pairs, whereas our algorithm requires 1.6 hours. The increased efficiency of our algorithm improves the feasibility of applying mutual information based approaches for reconstructing large regulatory networks. [Copyright &y& Elsevier]

Software industry development is acknowledged as an important engine of economic growth for many developing countries. The role of national policy has been identified as a catalyst to software industry and software exports development. Academic and practitioner frameworks have emerged to guide policymakers to the factors that are critical to success. This article adopts an institutional theory perspective on the strategy-making and implementation process and examines how historically rooted, taken-for-granted assumptions limit the possible courses of action and may also simultaneously open up new opportunities. Certain complexities and contradictions are highlighted through a longitudinal case study of Costa Rica where there is an ongoing strategic planning effort to increase software exports. Key findings from the research are related to improving our understanding of how software exports policy is influenced by local, emergent institutions that have been shaped by particular historical circumstances. © 2009 Wiley Periodicals, Inc. [ABSTRACT FROM AUTHOR]

Abstract: A novel architecture to accelerate a neocortex inspired cognitive model is presented. The architecture utilizes a collection of context switchable processing elements (PEs). This enables time multiplexing of nodes in the model onto available PEs. A streaming memory system is designed to enable high-throughput computation and efficient use of memory resources. Several scheduling algorithms were examined to efficiently assign network nodes to the PEs. Multiple parallel FPGA-accelerated implementations were evaluated on a Cray XD1. Networks of varying complexity were tested and indicate that hardware acceleration can provide an average throughput gain of 184 times over equivalent parallel software implementations. [Copyright &y& Elsevier]

Abstract: Timing has a key role in several traffic control functions encountered in modern packet-switched networks. In order to be effective, a timing unit must provide fine resolution, be simple to implement and scale well with the number of controlled traffic streams. This paper addresses the design, implementation and evaluation of a timing unit that can support accurate and efficient implementations of traffic shaping, policing and charging in packet-switched networks. The timing unit is implemented in hardware and, therefore, overcomes constraints associated with software-based timers. It accommodates a pool of independently-clocked timers and counters, organised in timing blocks, and, consequently, is able to support, in parallel, traffic streams with diverse timing requirements. The design supports shaping and policing through token buckets, leaky buckets and a scheme, variation of the token bucket, that aims at providing statistical quality of service guarantees by exploiting the effective rate concept. Charging is supported by dedicated counters that measure the utilization of the effective rate. The granularity of the timing unit is adjustable in run-time to adapt to changes in the rate parameters of the shaping and policing functions. The validation of the timing unit is done through the development of a prototype board consisting of programmable hardware and embedded software blocks. The temporal resolution of the timing unit and the advantages of the hardware/software co-design are experimentally evaluated. [Copyright &y& Elsevier]

In this study we focus on knowledge-intensive services used by small and medium-sized companies in the software industry. Our study explores the sources, use and perceived importance of different types of knowledge-intensive services in software business. In addition to revealing the use of commercial privately or publicly produced knowledge-intensive business services, the results of this study indicate the remarkable proportion and strategic role of non-commercial knowledge-intensive service activities that are co-produced in network partnerships. These activities are accomplished in networks in order to mutually generate or transfer knowledge between companies, customers, subcontractors or authorities of the industry, and the knowledge itself is not an object of trade. [ABSTRACT FROM AUTHOR]

Abstract: High-level performance estimation of embedded software implemented in a particular processor is essential for a fast design space exploration, when the designer needs to evaluate different processor architectures (and their different versions) and also different task allocations in a multiprocessor system. The development of fast and adequate performance estimators is required to achieve the necessary speed in this design phase. However, advanced architectures present many features, such as pipelines, branch prediction mechanisms, and caches, which have a non-linear impact on the execution time, which thus becomes hard to evaluate using simple linear methods. In order to cope with this problem, this paper presents a high-level performance estimator based on a neural network, which easily adapts to the non-linear behaviour of the execution time in advanced architectures and presents a speed-up up to 190 times in comparison with cycle-accurate simulators, using the PowerPC 750 as target architecture. A method for automatic domain classification is proposed to group applications with similar characteristics, resulting in an increase of the estimation precision. For the PowerPC 750, the mean estimation error has been reduced from 7.90% to 6.41% thanks to domain-specific estimators. This precision level and the fast estimation time are suitable for high-level design space exploration, when different architectures or processor versions and different task allocations need to be evaluated in a fast way. [Copyright &y& Elsevier]

The article reports on the study about aggregating experimental results derived from previous studies that address the same problem in unit testing in software engineering. The researchers aim to determine through experimental results the manner by which aggregation could help practitioners make better decisions. The researchers made of previous experiments dealing on the same problems through extensive research on the digital libraries. Most experiments chosen are focused on the effectiveness and efficiency of the techniques applied while others are laboratory experiments, thus, assuming that aggregation results are not conclusive and far from the ideal. INSET: Unit-Testing Techniques.

The article explores open-world software in the realm of business processes. The authors argue for the application of service-oriented design that has long driven the telecommunications infrastructure development and applications development. Because of its strong emphasis on modularization, development of service-oriented software radically alters the way business processes are modeled, realized, and maintained. The complex functions of the underlying business applications are virtualized by domain-specific services so that they can be loosely coupled to form transorganizational processes. They suggest new tools to guarantee a vertically seamless development of the modeled process.

We propose the first practical and secure way to integrate the iris biometric into cryptographic applications. A repeatable binary string, which we call a biometric key, is generated reliably from genuine iris codes. A well-known difficulty has been how to cope with the 10 to 20 percent of error bits within an iris code and derive an error-free key. To solve this problem, we carefully studied the error patterns within iris codes and devised a two-layer error correction technique that combines Hadamard and Reed-Solomon codes. The key is generated from a subject's iris image with the aid of auxiliary error-correction data, which do not reveal the key and can be saved in a tamper-resistant token, such as a smart card. The reproduction of the key depends on two factors: the iris biometric and the token. The attacker has to procure both of them to compromise the key. We evaluated our technique using iris samples from 70 different eyes, with 10 samples from each eye. We found that an error-free key can be reproduced reliably from genuine iris codes with a 99.5 percent success rate. We can generate up to 140 bits of biometric key, more than enough for 128-bit AES. The extraction of a repeatable binary string from biometrics opens new possible applications, where a strong binding is required between a person and cryptographic operations. For example, it is possible to identify individuals without maintaining a central database of biometric templates, to which privacy objections might be raised. [ABSTRACT FROM AUTHOR]

The article focuses on the software product blue print that would let stakeholders view a software project's status at any point in its development. It explains that one element of project management is cost and time estimation in which researchers in software engineering spent a great deal of effort in trying to effectively estimate a project's effort and duration and to develop supporting tools and metrics. The software product blueprint would likely be the answer, it is a high-level drawing of the software code modules and how these modules are decomposed, interact, and are deployed in hardware that would be helpful for progress tracking.

The article discusses how static code-analysis tools are used and what defects they can detect. It compares several open source tools which reduces the number of bugs of all software types before deploying the more expensive verification techniques. The author explains that programmers employs static checkers after compilation and before testing, they work with a program that has an initial indication of correctness and avoid well known traps and pitfalls before measuring it against its specifications. Open source tools used to detect defects includes FindBugs static code checking in Java developed by the University of Maryland, the program compiles but fails to do the programmers wants, and the PMD and Checkstyle, are tools used for coding problems.

In this paper we analyze the emergence of R&D services in Bangalore, India, by focusing on the process of technological upgrading in the Indian software industry. The development trajectory of the Indian software industry and the upgrading it has experienced, from providing low-skill software services to providing high-skill R&D services, are examined using evidence from interviews with Indian firms in Bangalore. Whereas most research on the Indian software industry thus far has emphasized the role of the state and multinational corporations, in this paper we argue that active local entrepreneurship is playing an increasingly important role in technological upgrading and in the shift from low-skill to high-skill services in Bangalore. These shifts are being facilitated by growing institutional thickness, as evidenced by the accumulation of local expertise, increasing local entrepreneurship addressing specific market niches, and the development of a local technical community. [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.

The article reports on the development of an architectural approach for effectively representing and analyzing fault-tolerant software systems. The proposed solution relies on exception handling to tolerate faults associated with component and connector failures, architectural mismatches, and configuration faults. The author implies that a well-structured system is essential for satisfying dependability-related requirements. From the fault-tolerance perspective, system structuring should ensure that the extra software involved in error detection and error handling.

The article focuses on the importance of architecture models and generic middleware on runtime adaptation for mobile computing applications. The architecture strongly influences the software system's properties, including maintainability and runtime properties such as performance and reliability. The three main functions of the middleware are: detect context changes, reason about the changes and make decisions about what adaptation to perform, and implement the adaptation choices. The author discusses the side effects of the development of adaptive applications, utilizing the architecture models at runtime. INSET: Changing Environments: An Example..

The article focuses on the importance of architecture information modeling language in simplifying the lengthy and costly certification of safety-critical software. Safety-critical systems, such as those in the avionics, automotive, power, space, and medical industries, are predominantly driven by real-time embedded software and are often referred to as high-integrity real-time systems (HIRTS). It also features an information model for the HIRTS domain, an amalgamation of modeling artifacts employed in the architectural and system design tools of the aerospace industry.

The article focuses on the use of architectural patterns and blueprints for service-oriented architecture (SOA). The author implies that in understanding SOA and all of its implications for software applications requires introducing a set of architectural principles that define SOA more concretely. The central objective of a service-oriented approach is to reduce dependencies between software islands, which basically comprise services and the clients accessing those services. The author also introduces the fundamental architectural principles that form the base of the current understanding of SOA systems.

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 focuses on the transition from basic research to an essential element of software system design and construction. The author examines software architecture's growth in the context of a technology maturation model, matching its significant accomplishments to the model's stages to gain perspective on where the field stands today. The authors also present the six typical phases of software technologies and they have concluded that software engineering research is often motivated by problems arising in producing and using real-world software.

The article focuses on the evolution of software architecture. The author discusses the innovative methods and techniques emerging from research to support software architecture practice. They also emphasize the methods, techniques, tools, and software engineering principles that support organizations taking an architecture-centric approach to software development. Software architecture involves the structure and organization by which modern system components and subsystems interact to form systems and the properties of systems that can best be designed and analyzed at the system level.

The article reports on the importance of object-oriented (OO) approach in achieving a high degree of reuse with the development of countless highly accessible libraries and frameworks and their concomitant availability. Examples of this reuse include graphical user-interface libraries such as Microsoft Foundation Classes and Java Swing, as well as container and algorithm classes such as the C standard library. However, reusing object libraries and frameworks requires skill in OO programming and an underlying knowledge of the classes, as well as the services that they provide.

In this paper we present the Gaia2JADE process concerning how one can implement a multi-agent system with the JADE framework using the Gaia methodology for analysis and design purposes. This process is particularly dedicated to the conversion of Gaia models to JADE code. It is described using the Software Process Engineering Metamodel (SPEM) and extends the one proposed by FIPA for describing the Gaia modeling process. Thus, it proposes to potential MAS developers a process that covers the full software development lifecycle. This work is based on the experience we have acquired by applying this process for implementing a real-word multi-agent system conceived for providing e-services to mobile users. With this paper, we share this experience with future multi-agent systems (MAS) developers, who would like to follow this process, taking into account several technical issues that emerged during the implementation phase, helping them to easily model and implement their systems. [ABSTRACT FROM AUTHOR]

Multi-agent systems are well suited for building large software systems. A great deal of these complex systems includes process flows that are concerned with time or are even time-critical. The activities of these process flows are often executed in distributed autonomous subsystems that have to be synchronized with respect to the superordinated task execution. To be able to build such systems and test their behavior adequately, it is often advantageous and sometimes necessary to simulate them in the run-up to their practical use. Testing and simulation of process flows within multi-agent systems requires synchronization of the participating agents with respect to the global simulation time. In this paper, a design proposal and a service implementation for time management is presented, which takes care of the special requirements imposed by multi-agent settings. This so-called time service is implemented as an FIPA-compliant agent, and can be used to couple heterogeneous subsystems implemented on different agent platforms. [ABSTRACT FROM AUTHOR]

Agents are good tools for providing Web services. They are usually either single agents, where one agent provides one or multiple services, or multiple individual agents that are discovered using UDDI. But then also a singular recipient is determined for fulfilling actual requests. This is well suited for smaller services, which are provided by a single, but perhaps complex, agent by itself. However, more difficult tasks will usually be solved by a system of agents. There, in some cases, an initial single point of contact will be useful, preventing exposure of individual service agents. Later on communication takes place with the specific agents directly, avoiding the bottleneck of a single “gateway” agent. Some guidelines when a single agent view is desirable and when exposing the system of agents is better suited are presented with the combination of both aspects through a gateway agent. Currently the latter approach is possible only through the application requesting the service itself. In this paper an extension to SOAP is presented, allowing redirection of Web service requests to another recipient by the (initial) service provider. An application is presented where redirection is used to distribute tasks to individual agents. [ABSTRACT FROM AUTHOR]

This paper addresses the issues related to improving the overall quality of the dynamic candidate link generation for the requirements tracing process for Verification and Validation and Independent Verification and Validation analysts. The contribution of the paper is four-fold: We define goals for a tracing tool based on analyst responsibilities in the tracing process, we introduce several new measures for validating that the goals have been satisfied, we implement analyst feedback in the tracing process, and we present a prototype tool that we built, RETRO (requirements tracing On-target), to address these goals. We also present the results of a study used to assess RETRO's support of goals and goal elements that can be measured objectively. [ABSTRACT FROM AUTHOR]

The article focuses on the computer software industry between 1960 and 1979. Software is not a new or unique concept; it is merely a structured way of describing a process. Similarly, as software is the description of a process--indeed, it is a precise enough description to actually drive the process--protections available to unique, non-obvious processes (like patents) should be available to software. In retrospect, the foregoing seems clear and obvious. The Association of Data Processing Service Organizations (ADAPSO) did not have any real presence in software until 1971 when it absorbed a small group of software product companies that had been organized under the name Software Industry Association. Jerry Dreyer, then ADAPSO's executive director, was anxious to move into software, and he created a sectional structure that let the data center people have their space while the software professionals had theirs. In 1972, another software group, the Association of Independent Software Companies, joined too. Once incorporated into the ADAPSO, software professionals gradually increased their power and representation. By the mid-1970s, the ADAPSO was ready to back the software section and take on International Business Machines Corp.

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]

The prevailing abstractions for software are better suited to the traditional problem of computation, namely transformation of data, than to the problems of embedded software. These abstractions have weak notions of concurrency and the passage of time, which are key elements of embedded software. Innovations such as nesC/TinyOS (developed for programming very small programmable sensor nodes called ‘motes’), Click (created to support the design of software-based network routers), Simulink with Real-Time Workshop (created for embedded control software) and Lustre/SCADE (created for safety-critical embedded software) offer abstractions that address some of these issues and differ significantly from the prevailing abstractions in software engineering. The paper surveys some of the abstractions that have been explored. [ABSTRACT FROM AUTHOR]

Recently a new product, named HunTeka has been introduced into the Hungarian library software market. Firstly the authors analyse the circumstances that gave reasons for the development of a new system on the overstocked market. After the introduction, the elements of the program system are presented according to the main modules of the system. Particular emphasis is laid on certain functions that are becoming more and more important nowadays, like high level support of the networking interoperability, distributed cataloguing, wide range application of the XML standards, or the chances of developing virtually common catalogues. The adoption of the CAl protocol in HunTeka is also emphasised, since this is the technical basis on which common searching inter- faces can be developed for the databases of libraries, museums and archives, or even for partner institutions and providers outside the public cultural sector. Finally the authors come to the conclusion that it was worth launching the development of HunTeka, which is confirmed by the growing number of the libraries introducing the new service. [ABSTRACT FROM AUTHOR]

Compositional adaptation enables software to modify its structure and behavior dynamically in response to changes in its execution environment. A review of current technology compares how, when, and where recomposition occurs. Moreover, this article will also offer a review of the supporting technologies, proposed solutions, and areas that require further study. Many of the mechanisms for compositional adaptation are available now, and we expect their use to increase as programmers become more familiar with adaptive software technologies and society comes to expect computer systems to manage themselves. Compositional adaptation is powerful, but without appropriate tools to automatically generate and verify code, its use can negatively impact, rather than improve, system integrity and security. The computer science community must build development technologies and tools, well grounded in rigorous software engineering, to support compositional adaptation. This foundation will raise next generation of computing to new levels of flexibility, autonomy, and maintainability without sacrificing assurance and security.

Software engineering environments have a history of about two decades. Early environments provided support for small fragments of the software process (usually focusing on programming-in-the small). Then there was a trend towards support for more complete software processes (from early phases like requirements analysis and design down to testing and configuration management). Ten years ago the notion of process-centered software engineering environments initiated a new field in software engineering: software process research. The key idea is to use a model of a software process as input parameter for a software engineering environment. The environment is supposed to "behave" in accordance to the process model. Some aspects of this vision became true, others turned out to be of little practicability. In this article, we discuss the history of software engineering environments with a particular focus on process-centered software engineering environments (PCSEEs). We discuss the notion of distributed software processes (as one of the most substantial current trends in software process research) and we motivate the notion of a software process middleware which serves as basis of real-world software processes spread over various sites. In addition, we discuss some other trends in the software process research arena. [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]

In the late 1970s, IBM software labs were aligned with the IBM hardware families. The decisions to commercialize the relational database prototype called System R, which had been developed during the 1970s at the IBM Research facility in San Jose, California, were made based on a hardware family business case. The Endicott Lab, supporting the small- to mid-sized mainframe environments running VM and VSE, had the skills and the competitive pressure to launch the relational database management system (RDBMS) commercialization project in 1979, and delivered SQL/DS two years later. This article traces how SQL/DS, running on VSE and then on VM, became IBM's first commercial relational database in 1982, over a year before the availability of DB2 running on MVS. [ABSTRACT FROM PUBLISHER]