Showing papers on "Implementation published in 2011"

The influence of organizational factors on successful ERP implementation

Abstract: Purpose – This study aims to examine organizational factors (i.e. top management support, training and education, enterprise‐wide communication) that may influence the enterprise resource planning system implementation success in Iran.Design/methodology/approach – Empirical data were collected via a survey questionnaire. The questionnaires were distributed to selected managers of companies adopting ERP systems in Iran.Findings – The results indicate that the companies' top management must provide full support and commitment to the project if the system is to be successful. In addition, management must also ensure the plans are communicated and understood by the entire company. Finally it is also illustrated that adequate training and education pertaining to the systems must be given to all users to ensure that they are able to use the system effectively and efficiently thus contributing to their satisfaction which will subsequently influence the implementation success.Research limitations/implications – T...

Relational verification using product programs

Abstract: Relational program logics are formalisms for specifying and verifying properties about two programs or two runs of the same program. These properties range from correctness of compiler optimizations or equivalence between two implementations of an abstract data type, to properties like non-interference or determinism. Yet the current technology for relational verification remains underdeveloped. We provide a general notion of product program that supports a direct reduction of relational verification to standard verification. We illustrate the benefits of our method with selected examples, including non-interference, standard loop optimizations, and a state-of-the-art optimization for incremental computation. All examples have been verified using the Why tool.

F4F: taint analysis of framework-based web applications

Abstract: This paper presents F4F (Framework For Frameworks), a system for effective taint analysis of framework-based web applications. Most modern web applications utilize one or more web frameworks, which provide useful abstractions for common functionality. Due to extensive use of reflective language constructs in framework implementations, existing static taint analyses are often ineffective when applied to framework-based applications. While previous work has included ad hoc support for certain framework constructs, adding support for a large number of frameworks in this manner does not scale from an engineering standpoint.F4F employs an initial analysis pass in which both application code and configuration files are processed to generate a specification of framework-related behaviors. A taint analysis engine can leverage these specifications to perform a much deeper, more precise analysis of framework-based applications. Our specification language has only a small number of simple but powerful constructs, easing analysis engine integration. With this architecture, new frameworks can be handled with no changes to the core analysis engine, yielding significant engineering benefits.We implemented specification generators for several web frameworks and added F4F support to a state-of-the-art taint-analysis engine. In an experimental evaluation, the taint analysis enhanced with F4F discovered 525 new issues across nine benchmarks, a harmonic mean of 2.10X more issues per benchmark. Furthermore, manual inspection of a subset of the new issues showed that many were exploitable or reflected bad security practice.

Critical factors for effective implementation of the HACCP system: a Pareto analysis

Abstract: Purpose – The main objective of this paper is to examine the existing literature on food safety assurance systems and record the vital critical factors that affect the implementation of these systems, in the context of the global food‐processing sector, for the benefit of researchers and industries.Design/methodology/approach – A range of published (1995‐2008) articles on food safety is explored that lists the motives for and the barriers to the implementation of the Hazard Analysis of Critical Control Point plan in descending order of frequency of occurrences. The barriers and motives in this study are referred to as “critical factors of effective implementation” (CFEIs). In addition, the Pareto analysis quality tool was used to sort and arrange the above‐mentioned barriers to and motives for CFEIs of the HACCP system implementation according to their order of criticality.Findings – The examination and analysis of 31 studies resulted in the identification of 32 factors that affect HACCP implementation. D...

The Science of Service Systems

Abstract: The Science of Service Systems intends to stimulate discussion and understanding by presenting theory-based research with actionable results. Most of the articles focus on formalizing the theoretical foundations for a science of service systems, examining a wide range of substantive issues and implementations related to service science from various perspectives. From the formal (ontologies, representation specifications, decision-making and maturity models) to the informal (analysis frameworks, design heuristics, anecdotal observations), these contributions provide a snapshot in time of the gradually emerging scientific understanding of service systems. The Science of Service Systems, along with its companion text, Service Systems Implementation, is designed to present multidisciplinary and multisectoral perspectives on the nature of service systems, on research and practice in service, and on the future directions to advance service science. These two volumes compose a collection of articles from those involved in the emerging area known as service science.

Anything but engaged: user involvement in the context of a national electronic health record implementation.

Abstract: Background The absence of meaningful end user engagement has repeatedly been highlighted as a key factor contributing to 'failed' implementations of electronic health records (EHRs), but achieving this is particularly challenging in the context of national scale initiatives. In 2002, the National Health Service (NHS) embarked on a so-called 'top-down' national implementation strategy aimed at introducing commercial, centrally procured, EHRs into hospitals throughout England. Objective We aimed to examine approaches to, and experiences of, user engagement in the context of a large-scale EHR implementation across purposefully selected hospital care providers implementing early versions of nationally procured software. Methods We conducted a qualitative, case-study based, socio-technically informed, longitudinal investigation, purposefully sampling and collecting data from four hospitals. Our data comprised a total of 123 semi-structured interviews with users and managers, 15 interviews with additional stakeholders, 43 hours of non-participant observations of meetings and system use, and relevant organisation- specific documents from each case study site. Analysis was thematic, building on an existing model of user engagement that was originally developed in the context of studying the implementation of relatively simple technologies in commercial settings. NVivo8 software was used to facilitate coding. Results Despite an enduring commitment to the vision of shared EHRs and an appreciation of their potential benefits, meaningful end user engagement was never achieved. Hospital staff were not consulted in systems choice, leading to frustration; they were then further alienated by the implementation of systems that they perceived as inadequately customised. Various efforts to achieve local engagement were attempted, but these were in effect risk mitigation strategies. We found the role of clinical champions to be important in these engagement efforts, but progress was hampered by the hierarchical structures within healthcare teams. As a result, engagement efforts focused mainly on clinical staff with inadequate consideration of management and administrative staff. Conclusions This work has allowed us to further develop an existing model of user engagement from the commercial sector and adapt it to inform user engagement in the context of large-scale eHealth implementations. By identifying key points of possible engagement, disengagement and re-engagement, this model will we hope both help those planning similar large-scale EHR implementation efforts and act as a much needed catalyst to further research in this neglected field of enquiry.

Beyond ERP implementation: The moderating effect of knowledge management on business performance

Abstract: The implementation of an enterprise resource planning (ERP) system is known to be time consuming and resource demanding. The success rate of implementation has been notoriously low. This may be attributed to the contextual factors of the implementing organisation. Previous studies of the success factors of ERP system implementation often overlook the contextual factors of post-implementation maintenance and knowledge management. This study intends to examine the extent to which these two contextual factors affect the performance of a business. In this study, we classify post-implementation into system maintenance and data maintenance. A sample of 600 large firms in Taiwan was surveyed and 110 usable questionnaires were collected. Using regression analysis to test the hypotheses, we found that post-implementation maintenance of an ERP system has significant influence on the performance of a business. Furthermore, system maintenance has a significant direct effect on business performance and the moderating ...

Capturing and exploiting abstract views of states in OO verification

Abstract: In this thesis, we study several implementation, specification and verification techniques for Object-Oriented (OO) programs. Our focus is on capturing conceptual structures in OO states in abstractions, and then exploiting such an abstract view of the state in specification and implementation approaches in a way that allows for formal verification. Generally, an OO state consists of many objects that reference each other in possibly complicated ways. At the same time, at any one point in the execution of the program, we can often reason about what is happening using an abstract view of the state that is much less complicated. To further improve the quality of implementations, better techniques must be developed for 1) specification of the abstract views that are used by the client and the programmer, and 2) the verification that an implementation satisfies its specification. This thesis contributes to that effort. We distinguish between client-level and programmer-level specification. A client-level specification acts as a contract between the client and the implementer. A programmer-level specification allows to reason formally about the implementation. We consider two specification formalisms that differ in the basic abstract view that is used: Algebraic Specification and OO Specification. We consider both client-level and programmer-level specifications based on algebraic specification. We contribute a novel syntax and semantics for the former, and we contribute an implementation approach for OO implementations based on the latter. We show that the implementation approach is suitable for problem-independent verification. We propose the programmer-level OO specification constructs inc and coop. The inc construct allows method specification to make explicit that a certain enumeration of invariants does not have to hold when that method is executed. The coop construct allows a field specification to make explicit that a certain enumeration of invariants might be invalidated when the field is updated. This allows for the specification and verification of OO designs in which in the process of updating one object, other objects with which it together implements a common purpose must be updated as well. We then generalize the inc and coop constructs by removing a restriction to enumerations of invariants. For instance, this is needed in the well-known Observer Pattern, where a Subject can have an arbitrary and dynamically changing number of Observers. A more general interpretation of invariants and accompanying proof system are provided as well. We contribute a programmer-level OO specification technique to capture layers in OO architectures, and we exploit these layers by providing a more liberal semantics of class invariants. We also provide a verification technique for the semantics. Layers are an abstraction at the architectural level in OO implementations that designate certain object structures in the design as sub-structures that are shared by other structures. An object in a higher layer is not relevant to the purpose of an object in the sub-structure. Given this intuition, an object in a higher layer is not part of the abstract view from an object in a lower layer. Therefore, the invariant of a higher layer object does not have to hold when a method of a lower-layer object is executing. Finally, we contribute a verification technique for pure methods and model fields, which are existing specification techniques for capturing an abstract view of the state in OO specifications. A method that is pure can be used as a function in predicates in class specifications. The function is axiomatized using the pre- and postcondition that are specified for the method. A model field abstracts part of the concrete state of an object into an abstract value. This too introduces an additional axiom in the underlying reasoning. The technique contributed establishes that such additional axioms do no introduce inconsistencies into the formal reasoning. It comes with heuristics that that make it amenable to automatic verification.

A STUDY OF ISSUES AFFECTING ERP IMPLEMENTATION IN SMEs

Abstract: Companies implement ERP systems to integrate the business processes of a company, and help organizations obtain a competitive advantage. Enterprise Resource Planning (ERP) is one of the solutions for the Small and Medium Enterprises (SMEs) in order to face the global challenges. This paper attempts to explore and identify issues affecting Enterprise Resource Planning (ERP) implementation in context to Indian Small and Medium Enterprises (SMEs) and challenges in front of SMEs. This paper attempts to highlight those specific issues where a different factors needs to be addressed while implementing the ERP system in this the four issues are proved to be crucial for SMEs such as proper system implementation, clearly defined scope of implementation procedure, proper project planning and minimal customization of the system selected for implementation.

Exploring the Impediments of Successful ERP Implementation: A Case Study in a Public Organization

Abstract: The implementation of ERP systems in the organizations is a complex process and a challenging task. Various factors may affect ERP system implementation leading to its success or failure in the organization. The on-going case study attempted to understand how and why different factors impeded successful ERP implementation in a public organization that outsourced the development and implementation of ERP system to a multi-national software company. The case study analysis explains that lack of consideration of certain factors such as top management support, user involvement, vendor support, overlooking of change management aspects, turnover of vendors team member, transfer/posting of top management of beneficiary organization affected ERP systems implementation in the organization and the project run over cost, behind schedule and was unable to meet user requirements. The findings are expected to provide valuable guidelines to the organizations planning to implement ERP systems.

The Common Communication Interface (CCI)

Abstract: There are many APIs for connecting and exchanging data between network peers. Each interface varies wildly based on metrics including performance, portability, and complexity. Specifically, many interfaces make design or implementation choices emphasizing some of the more desirable metrics (e.g., performance) while sacrificing others (e.g., portability). As a direct result, software developers building large, network-based applications are forced to choose a specific network API based on a complex, multi-dimensional set of criteria. Such trade-offs inevitably result in an interface that fails to deliver some desirable features. In this paper, we introduce a novel interface that both supports many features that have become standard (or otherwise generally expected) in other communication interfaces, and strives to export a small, yet powerful, interface. This new interface draws upon years of experience from network-oriented software development best practices to systems-level implementations. The goal is to create a relatively simple, high-level communication interface with low barriers to adoption while still providing important features such as scalability, resiliency, and performance. The result is the Common Communications Interface (CCI): an intuitive API that is portable, efficient, scalable, and robust to meet the needs of network-intensive applications common in HPC and cloud computing.

Modular reasoning for deterministic parallelism

Abstract: Weaving a concurrency control protocol into a program is difficult and error-prone. One way to alleviate this burden is deterministic parallelism. In this well-studied approach to parallelisation, a sequential program is annotated with sections that can execute concurrently, with automatically injected control constructs used to ensure observable behaviour consistent with the original program.This paper examines the formal specification and verification of these constructs. Our high-level specification defines the conditions necessary for correct execution; these conditions reflect program dependencies necessary to ensure deterministic behaviour. We connect the high-level specification used by clients of the library with the low-level library implementation, to prove that a client's requirements for determinism are enforced. Significantly, we can reason about program and library correctness without breaking abstraction boundaries.To achieve this, we use concurrent abstract predicates, based on separation logic, to encapsulate racy behaviour in the library's implementation. To allow generic specifications of libraries that can be instantiated by client programs, we extend the logic with higher-order parameters and quantification. We show that our high-level specification abstracts the details of deterministic parallelism by verifying two different low-level implementations of the library.

Exploring the relationship betweenweb application development tools and security

Abstract: How should software engineers choose which tools to use to develop secure web applications? Different developers have different opinions regarding which language, framework, or vulnerability-finding tool tends to yield more secure software than another; some believe that there is no difference at all between such tools. This paper adds quantitative data to the discussion and debate. We use manual source code review and an automated black-box penetration testing tool to find security vulnerabilities in 9 implementations of the same web application in 3 different programming languages. We explore the relationship between programming languages and number of vulnerabilities, and between framework support for security concerns and the number of vulnerabilities. We also compare the vulnerabilities found by manual source code review and automated black-box penetration testing. Our findings are: (1) we do not find a relationship between choice of programming language and application security, (2) automatic framework protection mechanisms, such as for CSRF and session management, appear to be effective at precluding vulnerabilities, while manual protection mechanisms provide little value, and (3) manual source code review is more effective than automated black-box testing, but testing is complementary.

Priority scheduling of distributed systems based on model checking

Abstract: Priorities are used to control the execution of systems to meet given requirements for optimal use of resources, e.g., by using scheduling policies. For distributed systems it is hard to find efficient implementations for priorities; because they express constraints on global states, their implementation may incur considerable overhead. Our method is based on performing model checking for knowledge properties. It allows identifying where the local information of a process is sufficient to schedule the execution of a high priority transition. As a result of the model checking, the program is transformed to react upon the knowledge it has at each point. The transformed version has no priorities, and uses the gathered information and its knowledge to limit the enabledness of transitions so that it matches or approximates the original specification of priorities.

A general extension system for event processing languages

Abstract: Event processing languages (EPLs) for Complex Event Processing (CEP) systems are descriptive in nature. This allows the authoring of event processing applications at a higher level of abstraction. However, they are less suitable for dealing with low- level tasks, such as String manipulation, and other programming- in-the-small problems. In addition, current EPL implementations lack the richness of other programming language libraries (e.g. Java), which have been built over several years of usage. We present an architecture whereby providers can integrate existing programming languages into CQL, our EPL language of choice, leveraging the advantages of other languages, while still retaining the expressiveness and conciseness of EPL. We also demonstrate how the architecture avoids the awkwardness of previous integration solutions, which generally were focused only at the function-level (e.g. User-Defined Functions, Java call outs). Rather, the outlined solution is realized at the language level, through the extension of language implementation artifacts, such as type systems; thus resulting in a seamless, precise, and naturally blended environment for developing CEP applications. The architecture is based upon the concept of extension cartridges, which are modules that provide metadata describing the extensions. Finally, we show how these extension cartridges may be used in real-world CEP scenarios.

Effects-Driven IT Development: Specifying, realizing, and assessing usage effect

Abstract: For customers information technology (IT) is a means to an end. This tight association between IT systems and their use is, however, often absent during their development and implementation, resulting in systems that may fail to produce desired ends. Effectsdriven IT development aims to avoid the chasm between development and implementation through a sustained focus on the effects to be achieved by users through their adoption and use of a system. This involves iteratively (a) specifying the purpose of the system in terms of effects, (b) developing an IT system and associated organizational change that realize the specified effects, and (c) measuring the absence or presence of the specified effects during pilot use of the system while also remaining alert to the emergence of beneficial but hitherto unspecified effects. In this paper we explore effects-driven IT development and discuss the possibilities and challenges involved in making it an instrument for managing IT projects. Two main challenges are that effects must be measured while development is still ongoing, making pilot implementations a central activity, and that vendor and customer must extend their collaboration, particularly concerning organizational implementation. Empirically, the paper is based on three cases from the Danish healthcare sector.

The Lean Journey: Implementing the Last Planner ® System in Construction

Abstract: The Last Planner system for production planning and control has helped construction projects improve planning reliability, production performance, and construction workflow. However, many organizations face significant hurdles when implementing the Last Planner system for the first time. The hurdles are multifaceted and are tied to organizational, cultural, and technical factors. This paper highlights implementation issues mentioned in the literature and reports implementation challenges and failures experienced on three construction projects. Using action-based research where the author was actively involved in implementing the Last Planner® system on the three projects, the paper presents a framework for successful implementation of the Last Planner® system on construction projects drawing on previous research, lessons learned from change management, and previous lean implementations. The suggested framework will be tested on future construction projects newly implementing The Last Planner system for proper model calibration.

Agency theory and consultant management in enterprise resource planning systems implementation

Abstract: Enterprise resource planning (ERP) systems are rapidly becoming the foundations to the decision support systems of many organizations, but have all too often failed to deliver their expected benefits. Most ERP implementation projects are carried out using implementation consultants hired from outside the client firm. The current study treated the consultants as agents and the clients as principals, and applied agency theory to test the consultant-client relationship as a predictor of ERP implementation project success.A survey collected responses from 192 client project managers who worked on the ERP implementation process in their organizations. Data analysis via structural equation modeling showed that more consultant monitoring predicts less moral hazard (i.e., consultant shirking), that less moral hazard predicts greater ERP project success, and that more monitoring directly predicts such success. However, the analysis failed to support expectations that more pre-qualification efforts (i.e., screening of the consultant) would lead to less adverse selection (i.e., the consultant's misrepresentation of skills) or that less adverse selection would lead to greater ERP success. Surprisingly greater incentive alignment predicted greater moral hazard, thus suggesting the potential of incentives to de-motivate rather than motivate.This study contributed by extending agency theory to outsourced information systems project implementation. It provided new, validated measures of prequalification efforts, monitoring, incentive alignment, moral hazard, and adverse selection constructs. The findings suggest that future researchers may want to learn more about incentive alignment and its impact, and that information systems project managers may want to monitor more to improve ERP and other large-scale system implementation success.

A simple abstraction for complex concurrent indexes

Abstract: Indexes are ubiquitous. Examples include associative arrays, dictionaries, maps and hashes used in applications such as databases, file systems and dynamic languages. Abstractly, a sequential index can be viewed as a partial function from keys to values. Values can be queried by their keys, and the index can be mutated by adding or removing mappings. Whilst appealingly simple, this abstract specification is insufficient for reasoning about indexes accessed concurrently. We present an abstract specification for concurrent indexes. We verify several representative concurrent client applications using our specification, demonstrating that clients can reason abstractly without having to consider specific underlying implementations. Our specification would, however, mean nothing if it were not satisfied by standard implementations of concurrent indexes. We verify that our specification is satisfied by algorithms based on linked lists, hash tables and B-Link trees. The complexity of these algorithms, in particular the B-Link tree algorithm, can be completely hidden from the client's view by our abstract specification.

Access Control Framework

Abstract: The described implementations relate to an access control framework for a database system. One implementation can receive, from a user, a request for data that identifies a resource, such as a view that obtains data from a database. The implementation can check the identity of the user to identify user roles associated with the user. The implementation can identify an access policy that is associated with the resource, and a rule that is associated with the access policy and applies to the user roles associated with the user. The rule can be applied to the request for data using attributes of the access policy. For example, if the request for data is a query on a view, the query can be rewritten to apply the rule.

Theoretical approaches to e-HRM implementations.

Abstract: There has been much research and many follow-up recommendations on how to introduce a new electronic human resource management (e-HRM) system to employees in order to avoid or minimize troubles during its implementation. However, implementation projects are known to be time consuming, indirect, and sometimes impulsive developments, leading to a mismatch between the initial ideas behind information technologies and the use in practice, the employees' perceptions and their experience. Paraphrasing Block, I put forward the following question: If I define successful e-HRM as one that is developed on-time and within budget, is reliable and easily maintained, and meets the specified requirements of HR professionals, line managers, and employees — how many organizations would acknowledge having successful e-HRM? (Block, R. (1983). The politics of project. New York: Yourdon Press). This chapter explores lessons from information technology (IT) studies that e-HRM researchers can learn and apply to better understand complex e-HRM implementation projects.

Systematic personnel participation for logistics improvement: A case study

Abstract: The main aim of this paper is to present, in a reasoned and detailed manner, a methodology for Employee Participation System implementation applied in logistics issues. Thus, key aspects are developed in the implementation according to literature, focusing more on the “how” than on the “why.” This methodology is illustrated with the analysis of a case study in the Spanish company GADISA. The participative approach applied in redesigning the processes has been one of the keys to its success, in terms of the efficiency of the actions and in the ease with which they were implemented. Although the main objective of the Employee Participation System was the decision of the Board, the personnel took part in its operational design, from the initial stages of its development, not only proposing improvements but also analyzing, implementing, and supervising alternatives. The proposed methodology may be of interest both in the academic and professional world. © 2010 Wiley Periodicals, Inc. © 2011 Wiley Periodicals, Inc.

Robust specification of real time components

Abstract: Specification theories for real-time systems allow to reason about interfaces and their implementation models, using a set of operators that includes satisfaction, refinement, logical and parallel composition. To make such theories applicable throughout the entire design process from an abstract specification to an implementation, we need to be able to reason about possibility to effectively implement the theoretical specifications on physical systems. In the literature, this implementation problem has already been linked to the robustness problem for Timed Automata, where small perturbations in the timings of the models are introduced. We address the problem of robust implementations in timed specification theories. Our contributions include the analysis of robust timed games and the study of robustness with respect to the operators of the theory.

Repository relationship programming

Abstract: Embodiments of systems, methods and computer program products are described for implementing repository relationship programming. Implementations described herein describe processes for implementing a union of concerns, integrating concerns, assembling concerns and separating concerns.

Generic middleware support for coordinating robot software components: The Task-State-Pattern

Abstract: Robot software systems are (again) reaching levels of size and complexity that makes them difficult to construct, evolve, and maintain. One current issue is that systems are increasingly built to perform many different tasks in parallel, each of which must be coordinated and monitored to achieve a goal. If all components were to require different interfaces, system complexity would rapidly grow. General interfaces partially exist on the conceptual level, but their implementations are typically strongly linked to particular architectural proposals, thus reducing re-use and comparability. This paper presents an architecture-agnostic design pattern for the coordination-related component interaction. It results in a simple and clean component interface to invoke specific functionality, monitor task progress, and update the goals of running tasks. It provides an abstract coordination interface with high observability for the development of coordination and architecture. It thus provides value to all stakeholders in the design and implementation of robot software systems: component developers, coordination developers, and system architects. We trace the convergence of concepts and approaches from early coordination systems and through various abstraction proposals. Recently, two very similar realizations were developed independently by the authors. This paper presents the underlying insights and practical experience as a generic software engineering method which we named the Task-State-Pattern. We describe the functionality it provides to component developers and detail the technical steps necessary to implement it in a distributed event-based toolkit for specific application domains. We provide empirical evidence for the relevance and utility of our approach by presenting case studies and discussing how the proposed pattern leads to a flexible system structure with reduced integration effort.

Advances in the development and application of an open source model server for building information

Abstract: The need for Building Information Model (BIM) servers to facilitate collaboration has been repeatedly reported in literature and stated by industry practitioners. To date, only a few commercial implementations of model servers are available. However, these applications are either limited to vendorspecific, proprietary data models or their complexity and pricing structure imposes a considerable threshold to their adoption by SMEs. The academic, standardization and development communities suffer a lack of open platforms that allows the integration and evaluation of research results and prototypes in a larger context. Although promising efforts aiming the creation of free and open platforms for a larger audience have been made in the past (Kiviniemi et al, 2005), none of these initiatives is still in existence to date. In this paper we report on the progress of the bimserver.org project, a collective effort to create a software framework that serves both as an open, low-cost entry into collaboration using shared building models for SMEs and as a test bed for research and development. We introduce conceptual, methodological and implementation specific advancements that have been made compared to earlier publications. Based on a series of interviews and a survey we report on user experiences that have been made by a diverse audience of architectural, engineering, project management companies as well as educational projects in academic environments and third party developers. A discussion of future research and development directions concludes this paper. Among these prospective additions to the framework are customizations and tailored solutions of external parties that use the open nature of the platform to suit their specific needs.

Erp implementation: A cross-cultural perspective

Abstract: The literature on ERP (Enterprise Resource Planning) systems implementation is replete with stories of unsuccessful project outcomes. One of the issues that have attracted relatively little research is the interplay between national culture and the manner in which the ERP project unfolds. The goal of this article is to explore this issue through the use of two case studies from the US and Italy. The data from the case studies is used to demonstrate the impact of national cultural on the two ERP implementation projects. Based on the unique patterns of the implementation process in each of the two cultures, broader issues of ERP implementation are explored and directions for future research on ERP implementation across cultures are proposed.