Software Engineering Perspective Research Articles

A Study of Mashup as a Software Application Development Technique with Examples from an End-User Programming Perspective

The purpose of this study is to present, introduce and explain the principles, concepts and techniques of mashups through an analysis of mashup tools from End-user Development (EuD) software engineering perspectives, since it is a new program ming paradigm. Problem statement: Although mashup tools supporting the creation of mashups rel y heavily on data integration, they still require users to have reasonable programming skills, rather than simply enabling the integration of content in a template approach. Mashup tools also have their lif espan in a fast moving technology-driven world which requires meta-application handling. Some developers have discontinued their mashup tools but others are still available in the mashup space. It has been noted that there is a steady increase of n ew mashups on a daily basis with a concomitant increas e of new Application Programming Interface (APIs) to support meta-mashup application EuD. Approach: Both qualitative and quantitative research methods have been utilized. After introducing the b asic principles, concepts and techniques of mashups, we develop and present a categorization of mashups and mashup tools and summarize the ten most popular currently used mashup tools against se ven indictors from end-user software engineering perspectives ranging from programming skill require ment, prompt suggestion of features use, operability, 'share-ability' and reuse, service, ty pe and target user, in order to evaluate how these mashup tools support end-user development. To perform the evaluation and produce the final results, the selected indicators' features have been horizon tally compared and comprehensively analyzed. Results: The philosophy of mashup is aimed at providing simple rapid program development by end- users with minimum programming skills. However, we observe that mashup tools typically follow four data processing styles: Webpage customization, wire paradigm, spreadsheet and programming by demonstration. These mashup tools are supposed to seamlessly and effortlessly assist end-users programming but this is not the case. Conclusion: From our research we concluded that some mashup tools are not really simple enough to handle and st ill require end-users to have a computer programmin g background to learn and understand its platform inf rastructures and mechanisms. These might all change in the near future. There are some companies that are now involved with mashup development which provide huge opportunities to both individual and organizational customers. Mashup have now become a commercial opportunity rather than a simple way of integrating data from Web 2.0 platforms.

Environment programming in multi-agent systems: an artifact-based perspective

This article introduces the notion of environment programming in software multi-agent systems (MAS) and describes a concrete computational and programming model based on the artifact abstraction and implemented by the CArtAgO framework. Environment programming accounts for conceiving the computational environment where agents are situated as a first-class abstraction for programming MAS, namely a part of the system that can be designed and programmed--aside to agents--to encapsulate functionalities that will be exploited by agents at runtime. From a programming and software engineering perspective, this is meant to improve the modularity, extensibility and reusability of the MAS as a software system. By adopting the A&A meta-model, we consider environments populated by a dynamic set of computational entities called artifacts, collected in workspaces. From the agent viewpoint, artifacts are first-class entities of their environment, representing resources and tools that they can dynamically instantiate, share and use to support individual and collective activities. From the MAS programmer viewpoint, artifacts are a first-class abstraction to shape and program functional environments that agents will exploit at runtime, including functionalities that concern agent interaction, coordination, organisation, and the interaction with the external environment. The article includes a description of the main concepts concerning artifact-based environments and related CArtAgO technology, as well as an overview of their application in MAS programming.

M‐JGRIM: a novel middleware for Gridifying Java applications into mobile Grid services

AbstractThe benefits of Grids for building massively distributed applications have been broadly acknowledged. However, the high complexity of developing Grid applications compromises the widespread adoption of the paradigm. In a previous paper (Future Gener. Comput. Syst. 2008; 24(2):99–118), we have described JGRIM, a method for easily ‘gridifying’ Java applications, based on non‐invasively injecting Grid functionality into ordinary code through Dependency Injection (DI). DI is similar to the Inversion of Control notion of object‐oriented frameworks and allows external services providing certain functionality to be injected into application components that require these services without affecting the components' implementation. In this paper, we briefly revisit JGRIM and present m‐JGRIM, a novel Java middleware that materializes JGRIM concepts by transforming ordinary applications into entities called Mobile Grid Services, i.e. gridified applications with mobile capabilities that live within a Grid. We also provide an evaluation of the performance of m‐JGRIM. Grid practitioners should find this paper useful in having an assessment of the practical benefits and costs of gridifying applications with the middleware, and a down‐to‐earth description of JGRIM, whose advantages for Grid‐enabling applications from a software engineering perspective have been already evaluated in (Future Gener. Comput. Syst. 2008; 24(2):99–118). Copyright © 2010 John Wiley & Sons, Ltd.

A UML-based approach for the development of shop floor control systems

As a key part of computer integrated manufacturing (CIM), shop floor control systems (SFCS) play an essential role in the effective operations of a shop floor. The development of SFCSs is an extremely complex process, given the requirements for synchronisation and coordination. Object-oriented methods offer a promising solution to develop a reusable, maintainable and interoperable SFCS. However, current O-O practices for developing SFCSs are hindered by proprietary representations, which may lead to problems with the portability and interoperability of models. UML, as an industrial standard for O-O notations, has been widely accepted by practitioners to describe static and dynamic parts of a complex system. From the perspective of software engineering, UML offers a variety of standard notations to support the full life-cycle of system development. In this paper, an approach to developing an SFCS using UML through analysis, design and implementation phases is presented, based on the three level hierarchical architecture. An example workstation is studied as an illustration to clarify the proposed approach. In addition to the reusability, portability and maintainability, the presented UML-based development enhances the efficiencies and qualities of SFCS development, considering a wide range of mature tool supports (such as Rational Rose) for UML are available.

Why software agents can be effective in biomedical sciences

Nowadays most of the software systems, tools, and applications in biomedical sciences are very complex and require high flexibility. Seemingly, it is difficult to identify a common underlying technology. In fact, each specific research field imposes its own constraints on the corresponding solutions. Nevertheless, at least from a software engineering perspective, the agent technology appears to fit the requirements imposed by such different research fields and encompasses most of the biomedical systems, tools, and applications in a unifying framework.

Developer autonomy in the FreeBSD open source project

Delegation of authority is the basic approach to coordination of work in FreeBSD, an open source software (OSS) project that develops and maintains an operating system. This essay combines a software engineering perspective with a knowledge creation perspective to discuss three central mechanisms in FreeBSD: (1) motivation, (2) quality control by frequent building, and (3) bugfixing by parallel debugging. It is argued that frequent building is the project’s key coordinating mechanism, and that build breakdowns play a constructive role in the processes of knowledge creation in FreeBSD.

A CSP and tabulation-based adaptive chemistry model

We demonstrate the feasibility of a new strategy for the construction of an adaptive chemistry model that is based on an explicit integrator stabilized by an approximation of the Computational Singular Perturbation (CSP)-slow-manifold projector. We examine the effectiveness and accuracy of this technique first using a model problem with variable stiffness. We assess the effect of using an approximation of the CSP-slow-manifold by either reusing the CSP vectors calculated in previous steps or from a pre-built tabulation. We find that while accuracy is preserved, the associated CPU cost was reduced substantially by this method. We used two ignition simulations – hydrogen–air and heptane–air mixtures – to demonstrate the feasibility of using the new method to handle realistic kinetic mechanisms. We test the effect of utilizing an approximation of the CSP-slow-manifold and find that its use preserves the order of the explicit integrator, produces no degradation in accuracy, and results in a scheme that is competitive with traditional implicit integration. Further analysis on the performance data demonstrates that the tabulation of the CSP-slow-manifold provides an increasing level of efficiency as the size of the mechanism increases. From the software engineering perspective, all the machinery developed is Common Component Architecture compliant, giving the software a distinct advantage in the ease of maintainability and flexibility in its utilization. Extension of this algorithm is underway to implement an automated tabulation of the CSP-slow-manifold for a detailed chemical kinetic system either off-line, or on-line with a reactive flow simulation code.

About “trivial” software patents: The IsNot case

So-called “trivial” software patents undermine the patenting system and are detrimental for innovation. In this paper we use a case-based approach to get a better understanding of this phenomenon. First, we establish a baseline for studying the relation between software development and intellectual property rights by formulating a life cycle for the patenting system as well as three variations of the software life cycle: the defensive patent-aware software life cycle that prevents patent infringements, the more offensive patent-based software life cycle that aims both at preventing infringements and at creating new patents, and the IPR-based software life cycle that considers all forms of protection of intellectual property rights including copyright and secrecy. Next, we study an application for a software patent concerning the inequality operator and a granted European patent on memory management. We also briefly mention other examples of trivial patents. These examples serve to clarify the issues that arise when integrating patents in the software life cycle. In an extensive discussion, we cover the difference between expression and idea, the role of patent claims, software patents versus computer implemented inventions, the role of prior art, implications of software patents for open source software, for education, and for government-funded research. We conclude the discussion with the formulation of an “integrity axiom” for software patent authors and owners and sketch an agenda for software patent research. We conclude that patents are too important to be left to lawyers and economists and that a complete reinterpretation of the patenting system from a software engineering perspective is necessary to understand all ramifications of software patents. We end with explicit conclusions and policy recommendations.

Reengineering of educational material: a systematic approach

In electronic learning, keeping learning material up-to-date is a recurring problem. In the past, this has mostly been done manually, with a frequent consequence that material becomes outdated since manual updates are neither systematic nor applied often enough. In this paper, we take a software engineering perspective on the problem of updating learning material for electronic platforms, and show how reengineering can help in this context. Specifically, we present a reference model for an e-learning reengineering process, and cast this model into the architecture of a component and configuration management system. Finally, we indicate how the approach can be exploited by showing an example, and outlining a global reuse strategy for educational material using software product lines.

The ArrayExpress gene expression database: a software engineering and implementation perspective

The lack of microarray data management systems and databases is still one of the major problems faced by many life sciences laboratories. While developing the public repository for microarray data ArrayExpress we had to find novel solutions to many non-trivial software engineering problems. Our experience will be both relevant and useful for most bioinformaticians involved in developing information systems for a wide range of high-throughput technologies. ArrayExpress has been online since February 2002, growing exponentially to well over 10,000 hybridizations (as of September 2004). It has been demonstrated that our chosen design and implementation works for databases aimed at storage, access and sharing of high-throughput data. The ArrayExpress database is available at http://www.ebi.ac.uk/arrayexpress/. The software is open source. ugis@ebi.ac.uk.

Network centric interoperability - Using a variable message format (VMF) based data-link to improve situational awareness and close air support (CAS)

Clearly demonstrated in the recent military deployments in Afghanistan and Iraq, one of the most significant challenges now facing the warfighter is how to seamlessly interface the myriad of disparate stand-alone situational awareness (SA) and close air support (CAS) systems into the DoD's Network Centric Warfare (NCW) infrastructure. This point was recently highlighted in the Secretary of Defense's testimony to the Senate Armed Services Committee. Referring to mission critical shortfalls that occurred during the IRAQ deployment, the Secretary discussed the state of the current warfighting environment (Rumsfeld and Franks, 2003). Although tremendous progress has been made in the integration of new and emerging technologies and their applications on the battlefield, there is still a significant lack of interoperability between various communication systems. To address these battlespace management environment issues, Raytheon Technical Services Company's Engineering and Production Support facility underwent a product development effort to provide a network centric interoperability demonstration for CAS. This demonstration utilized various Raytheon-fielded SA and CAS products in a representative CAS scenario interfacing to variable message format (VMF) based data links. This paper addresses the systems and software issues encountered during this successful demonstration of CAS battlespace connectivity. This presentation will also discuss lessons learned during our product development from both a systems and a software engineering perspective.

UML For Data Warehouse Dimensional Modeling

Dimensional modeling is a common modeling technique in data warehousing. It reflects a simple logical view of a data warehouse system. It can be easily mapped to a physicaldesign.Traditionaldimensionalmodelingisdata-orientedandsemantically informal. From a software engineering perspective, the informal notations and data-oriented feature are insufficient to tackle the complexity of large data warehouseprojects. UML, with its well-definedsemantics, is now a standard modeling language that is used to model the entire life cycle of a software system. UML has rich and extensible semantics. The combination of the knowledge in standard object-oriented modeling and dimensional modeling add variable semantics to dimensional modeling without losing its understandability. This paper proposes a metamodel for data warehouse dimensional modeling using UML. Based on this metamodel, we illustrate how to model the business process and data marts of a large mobile telephone company.

Comparison of JavaServer Pages and XSLT: a software engineering perspective

AbstractProfessional Web applications present their content and services by means of dynamically generated Web pages to the user—normally HTML pages. Basically, there are two different technologies available for dynamic Web page generation—JavaServer Pages and XML/XSLT. In this paper the alternative technologies are compared from a software engineering perspective.The basic concepts of JavaServer Pages and XML/XSLT are briefly explained with respect to Web page generation. A universal software architecture of the server side presentation tier is introduced and it is shown how both technologies fit into the universal architecture. Its fundamental idea is the clear separation of concerns according to the well‐established model‐view‐controller design pattern. The proposed architecture has proven its applicability in several enterprise applications. The main part of the paper deals with the comparison of JavaServer Pages and XML/XSLT. Quality criteria well‐established in software engineering practice are discussed with respect to JavaServer Pages and XML/XSLT, e.g. maintainability, extensibility, reusability, efficiency, portability, integration of methods and tools. The main emphasis is laid on the support of the model‐view‐controller pattern, since it is the most established design principle for user interface design. Copyright © 2003 John Wiley & Sons, Ltd.

Kalman filter recipes for real-time image processing

Kalman filters are an important technique for building fault-tolerance into a wide range of systems, including real-time imaging. From a software engineering perspective, however, it is not easy to build Kalman filters. Each has to be custom designed and most software engineers are not sufficiently grounded in the necessary systems theory to perform this design. The contributions of this paper, therefore, are a set of recipes for implementation of the Kalman filter to a variety of real-time imaging settings, the presentation of a set of object-oriented requirements, and a design for a class of Kalman filters suitable for real-time image processing. First, we describe the Kalman filter and motivate its use as a mechanism for fault-tolerant computing and sensor fusion. Next, the details of using Kalman filters in imaging applications are discussed and several associated algorithms presented. Then, the advantages of using object-oriented specification, design and languages for the implementation of Kalman filters are explored. Finally, we present a specification and design for a class of Kalman filters, which is suitable for coding. This work extends significantly upon that first appearing in 2003 at an SPIE conference (Laplante and Neill, proceedings of the real-time imaging conference, SPIE, Santa Clara, January 2003, pp. 22–29).

Using TOP-C and AMPIC to port large parallel applications to the Computational Grid

Porting large parallel applications to new and various distributed computing platforms is a challenging task from a software engineering perspective. The primary aim of this paper is to demonstrate how the development time to port very large applications to the Computational Grid can be significantly reduced. TOP-C and AMPIC are software packages that have each seen successful applications in their respective domains of parallel computing and process creation/communication over the Computational Grid. We combined the two packages in 1 man-week, thereby leveraging several man-years of previous independent software development. As a real world test case, the 1,000,000 line Geant4 sequential application was then deployed over the Computational Grid in 3 man-weeks by using TOP-C/AMPIC. The cluster parallelization of Geant4 using TOP-C is now included as part of the Geant4 4.1 distribution, and the integration of TOP-C/AMPIC and the Globus protocols will additionally enable the use of the fundamental Grid middleware services in the future.

Effort, co‐operation and co‐ordination in an open source software project: GNOME

Abstract This paper presents results from research into open source projects from a software engineering perspective. The research methodology employed relies on public data retrieved from the CVS repository of the GNOME project and relevant discussion groups. This methodology is described, and results concerning the special characteristics of open source software development are given. These data are used for a first approach to estimating the total effort to be expended.

Organisational scenarios and legacy systems

A legacy system is made up of technical components and social factors (such as software, people, skills, business processes) which no longer meet the needs of the business environment. The study of legacy systems has tended to be biased towards a software engineering perspective and to concentrate on technical properties. This paper suggests that the evaluation of potential change options for legacy systems can only be carried out as part of an holistic organisational analysis. That is, the evaluation of legacy systems must take place within a framework that combines business and technical considerations. In particular, we believe that the business strategy must lead this process. Accordingly, we have designed an inter-disciplinary approach which brings together an organisational scenarios tool (based on concepts from the field of organisational development) and a technical scenarios tool (based on concepts from the field of software engineering). These tools are applied in an iterative way, so that technical options are tested out against the business needs. It is, thus, a dynamic tool which seeks to mimic the nature of organisational change, as far as is practicable. The research project described here is entitled software as a business asset (SABA) and was funded by the Engineering and Physical Sciences Research Council (EPSRC) under the systems engineering for business process change (SEBPC) programme. This paper describes the research approach and its iterative stages, and illustrates its use within a large engineering firm (Engco). Its application produced useful insights for the organisation, as well as pointers for further modification of our research approach.

Research Commentary: Introducing a Third Dimension in Information Systems Design—The Case for Incentive Alignment

Prior research has generated considerable knowledge on information systems design from software engineering and user-acceptance perspectives. As organizational processes are increasingly embedded within information systems, one of the key considerations of many business processes—organizational incentives—should become an important dimension of any information systems design and evaluation, which we categorize as the third dimension: incentive alignment. Incentive issues have become important in many IS areas, including distributed decision support systems (DSS), knowledge management, and e-business supply chain coordination. In this paper we outline why incentives are important in each of these areas and specify requirements for designing incentive-aligned information systems. We identify and define important unresolved problems along the incentive-alignment dimension of information systems and present a research agenda to address them.

A software engineering perspective on algorithmics

Analgorithm componentis an implementation of an algorithm which is not intended to be a stand-alone module, but to perform a specific task within a large software package or even within several distinct software packages. Therefore, the design of algorithm components must also incorporate software-engineering aspects. A key design goal is adaptability. This goal is important for maintenance throughout a project, prototypical development, and reuse in new, unforseen contexts. From a theoretical viewpoint most algorithms apply to a range of possible use scenarios. Ideally, each algorithm is implemented by one algorithm component, which is easily, safely, and efficiently adaptable to all of these contexts.Various techniques have been developed for the design and implementation of algorithm components. However, a common basis for systematic, detailed evaluations and comparisons in view of therealpractical needs is still missing. Basically, this means a set of concrete criteria, which specify what sort of adaptability isreallyrequired in practice, and which are well-justified by convincing, representative use scenarios.This paper is intended to be a first “milestone” on the way towards such a system of criteria. We will present a set of concrete goals, which are general and problem-independent and might appear ubiquitously in the algorithmic realm. These goals are illustrated, motivated, and justified by an extensive requirements analysis for a particular algorithm from a particular algorithmic domain: Dijkstra's algorithm for shortest paths in networks.Clearly, the field of algorithmics might be too versatile to allow a comprehensive, yet concise set of precise, justified criteria. Even a domain as restricted as graph and network algorithms includes aspects that are not fully understood. The analysis will include a discussion of the limits of the case study and the scope of the goals. The case study was chosen because it seems to be close to the “boderline” between the aspects that are well understood and the aspects that are not. Hence, this example may well serve as an“acid test” for programming techniques in view of the state of the art.

Introducing a Third Dimension in Information Systems Design: The Case for Incentive Alignment

Prior research has generated considerable knowledge on information systems design from software engineering and user-acceptance perspectives. As organizational processes are increasingly embedded within information systems, one of the key considerations of many business processes — organizational incentives — should become an important dimension of any information systems design and evaluation, which we categorize as the third dimension: incentive alignment. Incentive issues have become important in many IS areas, including distributed decision support systems (DSS), knowledge management, and e-business supply chain coordination. In this paper we outline why incentives are important in each of these areas and specify requirements for designing incentive-aligned information systems. We identify and define important unresolved problems along the incentive-alignment dimension of information systems and present a research agenda to address them.