Transaction Management

AI models used for fraud detection are constantly updated to tackle new threats, but their explanation methods often stay
static, leading to outdated or misleading interpretations. This research explores how adaptive explainable AI (XAI) can generate real
time, accurate explanations that evolve alongside the models they describe. We introduce a framework for self-updating narrative
generation, combining retrieval-augmented generation (RAG) and meta-learning to ensure explanations stay aligned with the latest
model behavior and emerging fraud patterns. Testing on real-world transaction data, we compare adaptive narratives against traditional
static explanations, measuring robustness, response time, and user understanding. Our results show that adaptive XAI not only preserves
transparency in fast-changing fraud environments but also builds stronger trust among users, auditors, and regulators. This work offers
a practical solution for real-time interpretability in AI-driven fraud detection-a critical need for deployable, trustworthy systems

MACH is an operating system kernel under development at Carnegie-Mellon University to support distributed and parallel computation. MACH is designed to support computing environments consisting of networks of uniprocessors and multiprocessors. This manual describes the interface to the MACH kernel in detail. The MACH system currently runs on a wide variety of uniprocessor and multiprocessor architectures.

02 is the Object-Oriented Database System being developed at Alta'ir. The 02 Object Manager is the layer of the system concerned with complex object access and manipulation, transaction management, persistence and disk management., and distribution in the server/workstation configuration. This paper describes the main choices made in the design of the Object Manager, and presents its overall architecture.

In this paper, I describe first the background behind the development of the original ARIES recovery method, and its significant impact on the commercial world and the research community. Next, I provide a brief introduction to the various concurrency control and recovery methods in the ARIES family of algorithms. Subsequently, I discuss some of the recent developments affecting the transaction management area and what these mean for the future. In ARIES, the concept of repeating history turned out to be an important paradigm. As I examine where transaction management is headed in the world of the internet, I observe history repeating itself in the sense of requirements that used to be considered significant in the mainframe world (e.g., performance, availability and reliability) now becoming important requirements of the broader information technology community as well.

Most distributed operating systems constructed to date have lacked a unifying mechanism for naming and protection. In this paper we discuss a system, Amoeba, that uses capabilities for naming and protecting objects. In contrast to traditional, centralized operating systems, in which capabilities are managed by the operating system kernel, in Amoeba all the capabilities are managed directly by user code. To prevent tampering, the capabilities are protected cryptographically. The paper describes a variety of the issues involved, and gives four different ways of dealing with the access rights. This paper describes a scheme in which user processes manipulate capabilities directly in their own address spaces. Except for some very special parts of it, the kernel does not even know that capabilities are in use. To prevent users from forging new capabilities or tampering with existing ones, capabilities are protected cryptographically. This cryptographic protection scheme will first be described in some detail, followed by a discussion of how these capabilities are used in the Amoeba distributed operating system. Amoeba is an object-oriented distributed operating system. Its semantic model is based on having client processes perform operations on objects managed by server processes. Objects are specified by capabilities. Operations are carried out by having processes exchange messages, generally in the form of a request from a client followed later by a reply from a server. The standard message format provides a place for one capability in the header, typically for the object being operated on, but users are free to put other capabilities in the data field as required. The header also contains room for the operation code and some parameters. After making a request, a client blocks until the reply comes in, so the approach can be regarded as a simple remote procedure call mechanism . The system does not use "connections" or virtual circuits or any other long-lived communication structures.

The power of networks manifests itself in a highly non-linear amplification of a number of effects, and their weaknessin propagation of cascading failures. The potential systemic risk effects can be either exacerbated or mitigated, depending on the resilience characteristics of the network. The goals of this paper are to study some characteristics of network amplification and resilience. We simulate random Erdős-Rényi networks and measure amplification by varying node capacity, transaction volume, and expected failure rates. We discover that network throughput scales almost quadratically with respect to the node capacity and that the effects of excessive network load and random and irreparable node faults are equivalent and almost perfectly anticorrelated. This knowledge can be used by capacity planners to determine optimal reliability requirements that maximize the optimal operational regions.

The power of networks manifests itself in a highly non-linear amplification of a number of effects, and their weaknessin propagation of cascading failures. The potential systemic risk effects can be either exacerbated or mitigated, depending on the resilience characteristics of the network. The goals of this paper are to study some characteristics of network amplification and resilience. We simulate random Erdős-Rényi networks and measure amplification by varying node capacity, transaction volume, and expected failure rates. We discover that network throughput scales almost quadratically with respect to the node capacity and that the effects of excessive network load and random and irreparable node faults are equivalent and almost perfectly anticorrelated. This knowledge can be used by capacity planners to determine optimal reliability requirements that maximize the optimal operational regions.

Multiple computers and/or processors offer interactive music systems more processing power, more inputs and outputs, and more tolerance to failure. Systems based on multiple computers require careful design paying particular attention to communication and configuration. The virtual patchbay is a new structure in Aura that simplifies the configuration and interconnection of objects in a distributed computer music application. The virtual patchbay also optimizes configurations to reduce the number of duplicate messages sent over the network and helps the system tolerate crashes and rebooting while other components continue to function.

The commit processing in a Distributed Real Time Database (DRTDBS) can significantly increase execution time of a transaction. Therefore, designing a good commit protocol is important for the DRTDBS; the main challenge is the adaptation of standard commit protocol into the real time database system and so, decreasing the number of missed transaction in the systems. In these papers we review the basic commit protocols and the other protocols depend on it, for enhancing the transaction performance in DRTDBS. We propose a new commit protocol for reducing the number of transaction that missing their deadline.

The healthcare industry is becoming more and more distributed; organizations are increasingly relying on mobile links to access patient information and to update their databases at the point of care. New technologies, such as Internet solutions or wireless, are enabling the widely disparate systems used in healthcare to communicate with each other and are reducing the cost of integration. Hospitals can access critical patient information and billing data from anyplace and anytime, including community clinics, patient homes, or at the scene of an emergency. In this article, we will present a mobile hospital solution that is based on DB2 Everyplace. DB2 Everyplace extends the power of database systems to handheld devices for the ever-growing mobile business environment. The article continues with a medical scenario that describes an application for home care nurses. The article closes with a short description of a mobile hospital solution with DB2 Everyplace in a Canadian hospital.

This tutorial explains how to build a cloud-native architecture for fintech applications using scalable components and frameworks that provide enterprise-grade features. The tutorial focuses on applications that process payments and that expose a service-oriented public API, even if the concepts and components used can be extended to all sorts of fintech applications. provide illustrative step-by-step examples to show how each component can be implemented using open-source technologies. Testing and employment on the cloud are also considered. The reference architecture consists of: a distributed event-driven design pattern to decouple the business process from the storage mechanisms. The Distributed Data Store (DDS) component allows to store and query sensitive data in a performant way, providing out-of-the-box, high-availability; scalability; and enterprise-grade features, such as ACID transactions and a row-level security mechanism; a remarkable, opensource distributed engine that enables to massively parallelize ingestion, visualization, and mesh queries on large datasets, leveraging such a DDS; a highly scalable Cloud-Native API Gateway that exposes GraphQL APIs. It can also serve static content such as documentation; server-side rendering; and login pages, among others, for the UI scheme; a Native-Cloud Serverless Function executor that processes resilient workloads and enables a pay-for-use architecture. It automatically scales workers up and down in a pay-per-execution pricing model; a cloud-native load balancer to distribute workloads between multiple instances of the resilient microservice; a Managed Workflow Engine that orchestrates the execution of long-running business processes in a distributed way, internally relying on a durable DDS. The architecture is implemented at the level of a complete payment service. The focus is on how to build a scalable service adapter capable of performing resilient messaging and processing of payments between an exogenous payment manager and an internal event store.

A real time distributed computing has heterogeneously networked computers to solve a single problem. So coordination of activities among computers is a complex task and deadlines make more complex. The performance of the system depends on many factors such as traffic workloads data base system architecture, underlying processor, disk speeds, concurrency control, transaction management etc.[1,2,3,4,5,6].  A simulation study have  to be performed to analyze the performance under different transaction scheduling, different workloads, arrival rate priority policies, altering slack factors and preemptive policies. The performance of the distributed system under various conditions is to be monitored and parameters such as arrival rate, transaction size, transaction distribution policies, and execution time are to be analyzed

Today, data is flowing into various organizations at an unprecedented scale. The ability to scale out for processing an enhanced workload has become an important factor for the proliferation and popularization of database systems. Big data applications demand and consequently lead to the developments of diverse large-scale data management systems in different organizations, ranging from traditional database vendors to new emerging Internet-based enterprises. In this survey, we investigate, characterize, and analyze the large-scale data management systems in depth and develop comprehensive taxonomies for various critical aspects covering the data model, the system architecture, and the consistency model. We map the prevailing highly scalable data management systems to the proposed taxonomies, not only to classify the common techniques but also to provide a basis for analyzing current system scalability limitations. To overcome these limitations, we predicate and highlight the possible principles that future efforts need to be undertaken for the next generation large-scale data management systems.

Multilevel petrinets are proposed for facilitating flexible modeling and control of complicated dynamic processes. A metapetrinet is able not only to change the marking of a petrinet but also to reconfigure dynamically its structure. Each level of the metanet is an ordinary petrinet of some traditional type. A basic level petrinet simulates the process of some application. The second level, i.e. the metapetrinet, is used to simulate and help controlling the configuration change at the basic level. There is conformity between the places of the second level structure and places or transitions of the basic level structure. The main control rule is such that a certain place or transition is removed from the present configuration of the basic level if the corresponding place at the metalevel becomes empty. If at least one token appears to an empty metalevel place, then the originally defined corresponding basic level place or transition immediately is created back to the configuration. We also introduce multilevel metapetrinets where every upper level may change the configuration of the previous lower level. In such a case even a few levels with a simple structure are able to simulate quite complicated control processes at the basic level. We assert that metapetrinets offer more compact facilities to the models of complex dynamic processes than single level petrinets.

In many workloads, most write operations performed on a file system modify only a small number of blocks. The log-structured file system was designed for such a workload, additionally with the aim of fast crash recovery and system snapshots. Surprisingly, although implemented for Berkeley Sprite and BSD systems, there was no complete implementation for the current Linux kernel. In this paper, we present a complete implementation of the log-structured file system for the Linux kernel, which includes a user-space garbage collector and additional tools. We evaluate the measurements obtained in several test cases and compare the results with widely-used ext3.

This paper explains Concurrency control is a database management systems concept that is used to address occurs with a multiuser system. It helps you to make sure that database transactions are performed concurrently without violating the data integrity of respective databases. Concurrency control when applied in advanced database management system is meant to coordinate simultaneous transactions while preserving data integrity. When more than one transactions are running simultaneously there are chances of a conflict to occur which can leave database to an inconsistent state. To handle these conflicts we need concurrency control in advanced DBMS, which allows transactions to run simultaneously but handles them in such a way so that the integrity of data remains intact.

Automation and intelligence constitute a major preoccupation in the field of software engineering. With the great evolution of Artificial Intelligence, researchers and industry were steered to the use of Machine Learning and Deep Learning models to optimize tasks, automate pipelines, and build intelligent systems. The big capabilities of Artificial Intelligence make it possible to imitate and even outperform human intelligence in some cases as well as to automate manual tasks while rising accuracy, quality, and efficiency. In fact, accomplishing software-related tasks requires specific knowledge and skills. Thanks to the powerful capabilities of Artificial Intelligence, we could infer that expertise from historical experience using machine learning techniques. This would alleviate the burden on software specialists and allow them to focus on valuable tasks. In particular, Model-Driven Engineering is an evolving field that aims to raise the abstraction level of languages and to focus more on domain specificities. This allows shifting the effort put on the implementation and low-level programming to a higher point of view focused on design, architecture, and decision making. Thereby, this will increase the efficiency and productivity of creating applications. For its part, the design of metamodels is a substantial task in Model-Driven Engineering. Accordingly, it is important to maintain a high-level quality of metamodels because they constitute a primary and fundamental artifact. However, the bad design choices as well as the repetitive design modifications, due to the evolution of requirements, could deteriorate the quality of the metamodel. The accumulation of bad design choices and quality degradation could imply negative outcomes in the long term. Thus, refactoring metamodels is a very important task. It aims to improve and maintain good quality characteristics of metamodels such as maintainability, reusability, extendibility, etc. Moreover, the refactoring task of metamodels is complex, especially, when dealing with large designs. Therefore, automating and assisting architects in this task is advantageous since they could focus on more valuable tasks that require human intuition. In this thesis, we propose a cartography of the potential tasks that we could either automate or improve using Artificial Intelligence techniques. Then, we select the metamodeling vii task and we tackle the problem of metamodel refactoring. We suggest two different approaches: A first approach that consists of using a genetic algorithm to optimize set quality attributes and recommend candidate metamodel refactoring solutions. A second approach based on mathematical logic that consists of defining the specification of an input metamodel, encoding the quality attributes and the absence of smells as a set of constraints and finally satisfying these constraints using Alloy.

The paper describes real time extensions to the Open Object Oriented Database system using the RTSORAC data model. This model combines an object oriented data model, real time requirements, flexible transactions, semantic relationships among objects, and active database features. Several extensions to the Open Object Oriented Database system, including development of interfaces for real time objects and real time transactions, use of a real time operating system, incorporation of real time object management, and incorporation of real time transaction management, are also described

ehps.net/ehp The European Health Psychologist This update includes information regarding the EHPS-UNDPI members’ activities during the past four years. The following sections delineate our status and activities related to the UNDP. It has now been four years since EHPS was formally associated with the Division of Public Information/ NGO section at the United Nations (since April 29th 2011). During that time the EHPS – UN Committee has been in discussion with EHPS National Delegates and all members about the role of health psychology in contributing to global health research and policy, to the Millennium Development Goals (MDGs), and currently, to the Sustainable Development Goals (SDGs). We have recently had a major success (April 2015) when the EHPS was accredited for ECOSOC consultative status. This means, given our dual status (UN-DPI & ECOSOC status), we can have a significant influence on global health and wellbeing policies. During the past four years we have initiated several...

The task of WP6 is to evaluate the CONNECT technologies under realistic situations. To achieve this goal, WP6 concentrated its 3rd year effort on the development of a main scenario in the context of GMES, which requires the connection of highly heterogeneous and independently built systems provided by the industry partners.

In this paper, we have proposed the strategies for concurrency control of global transactions in heterogeneous distributed database systems. We have focused on the issues of consistency, local autonomy and performance. A technique to prevent and resolve inconsistency, classified into one of the two basic approaches: optimistic or pessimistic. The previous research intends to provide a high degree of concurrency among global transactions, while the later is concerned with aborts of global transactions. The strengths and weaknesses of the two approaches are discussed.

The Race condition is a privilege escalation vulnerability that manipulates the time between imposing a security control and using services in a UNIX like system. This vulnerability is a result of interferences caused by multiple sequential threads running in the system and sharing the same resources. Race condition could occur due to sequence condition imposed by un-trusted processes or locking failure condition imposed by secure programs such as operating systems. The race condition is a common vulnerability in UNIX-like systems, where directories such as /tmp and /var/tmp are shared between threads. A study of Race condition vulnerability and its impact in UNIX like systems are presented in this paper. Also various types of Race condition attack and there detection, avoidance and prevention techniques are also discussed in this paper.

The payment industry has undergone successful innovation in the last decade due to technological change and other drivers that require efficiency in payment systems. Some of the most effective tools currently being used to create such systems include Java and Spring Boot, which are powerful frameworks allowing developers to create superb payment solutions that can undergo intense stress without compromising on flexibility. This work introduces some aspects of the complete lifecycle of payment systems developed with Java and Spring Boot, including the considerations from the conceptual environment to large-scale production, including issues of scalability, security, transactional processes, and interfaces with third parties. Payment systems in the twenty-first century are conducted at a very large scale and thus require the highest optimization and Java because of its feature of platform independence and Spring Boot because of its features of building microservices are best suited for building these systems. Some fundamental design issues deliberated comprise database control, how transactions are dealt with at the same time, protection of the payment modes, and sanction of financial laws. Since Java has various libraries and Spring Boot has numerous built-in facilities, developers can save much time and release solutions into markets securely. However, it should be noted that core concerns include the problem of transactional integrity and protection against different types of threats, including fraud or access of unauthorized users. This paper outlines key problems and provides a detailed step-by-step guide to the methodology for constructing payment systems, from requirement analysis to testing and implementation. Using examples of real companies, we show how the described technologies are used in practice and in which industriese-commerce, digital wallets, and subscription services. At last, the paper considers further developments of the topic: the application of AI to improve fraud prevention and blockchain to increase transparency of payments; and the constant advancements in microservices. The conclusion highlights the idea that the payment system is a continuous process through the help of tools Java and Spring Boot, as these tools would remain important in dealing with new challenges that crop up in the industry.

There is a tremendous growth of the mobile users everywhere which in turn leaded to high bandwidth requirements of new cellular services. But the bandwidth scenario is dependent on limited spectrum resources that have been allocated for mobile communications. Basically, three caching strategies have been discussed in this paper. An adaptive cache invalidation algorithm known as Bit Sequence for client server mobile environment; the next approaches discussed are:1. Asynchronous Invalidation Message technique 2. Caching using data replication from servers at the Mobile Host’s Home Location Cache, abbreviated as HLC, during the network is wholly disconnected from the network & apparently, it delivers it back the invalidations details to the Mobile Host when it is reconnected; and the final approach is using the fundamentals of Data Replication for Caching strategies. Past few decades have given tremendous growth of research in caching technology of mobile computing. This particular pap...

Abstract. Mapping XML documents into relational database is a promising solution because relational databases are mature and scale very well and they have the advantages that in a relational database XML data and structured data can coexist making it possible to build application that involve both kinds of data with little extra effort. In this paper, we propose two algorithms (XRD, XRS) that maps XML documents into relational database. The algorithm steps are given in details to describe how to map the XML documents into relational ...

Due to the successful development of the Internet, the course of distributed systems has received great attention by many universities and colleges in their computer science curricula. A comprehensive distributed system course involves many disciplines, such as ...

Data is often replicated in distributed database applications to improve availability and response time. Conventional multi-copy algorithms deliver fast response times and high availability for read-only transactions while sacrificing these goals for updates. In this paper, we propose a multi-copy algorithm that works well in both retrieval and update environments by exploiting special application semantics. By subdividing transactions into various categories, and utilizing a commutativity property, we demon strate cheaper techniques and show that they guarantee correct ness. A performance comparison between our techniques and con ventional ones quantifies the extent of the savings.

In this paper, we introduce and describe directed dependency graph-based transaction and concurrency control (DCC) for persistent (stable, single-level) object-based bulk data management systems. The new technique is optimistic and applicable across a wide range of store sizes, transaction sizes and multi-programming levels. It is also has potential for use in management of transactions in other contexts, for example web services. GRAPH-BASED OPTIMISTIC TRANSACTION MANAGEMENT 132 J OURNAL OF OBJECT TECHNOLOGY V OL. 6, NO. 6

We introduce IceFS, a novel file system that separates physical structures of the file system. A new abstraction, the cube, is provided to enable the grouping of files and directories inside a physically isolated container. We show three major benefits of cubes within IceFS: localized reaction to faults, fast recovery, and concurrent filesystem updates. We demonstrate these benefits within a VMware-based virtualized environment and within the Hadoop distributed file system. Results show that our prototype can significantly improve availability and performance, sometimes by an order of magnitude.

This research work addresses the daily challenges encountered by loan applicants requesting for loan facilities from a loan scheme and the unnecessary end-to-end delays in the processing and some time the computational errors associated with the conventional ways of handling these task. An Automated Workflow Execution of loan transaction processing for distributed environment was designed as a result of the shortcomings attributed to the traditional system/environment for loan processing, web development tools such as Hypertext Markup Language (HTML), Hypertext Preprocessor (PHP), JavaScript, and MySQL were used to realize the web interface, and the distributed Automated Workflow Execution Engine for loan transaction processing. We achieved our objective in designing of the distributed software architecture and developing the web based automated workflow execution system to solve local loan transaction problems. A comparative evaluation in terms of features and functionalities was also done between the proposed system and five commercial automated workflow systems. Results revealed that the proposed system has lightweight architecture in terms of design patterns and the development tools used.

As mobile devices get ubiquitous and grow in computational power, their management of interdependent data also becomes increasingly important. The mobile environment exhibits all the characteristics of a distributed database plus the feature of whimsical connectivity. Consequently, transactions respecting data consistency can suffer unbounded and unpredictable delays at both mobile and stationary nodes. The currently popular multi-tier model, in which mobile devices are in one end and always-connected stationary servers in the other, has certain practical advantages. However, it assumes that all integrity constraints are evaluated at the servers and hence relies on the semantics of operations for any autonomy enhancement of the mobile devices. In this paper, we examine the idea of constraint localization in cases where two mobile nodes each own data that share a constraint. It relies on reformulation of a constraint into more flexible local constraints that give more autonomy to the mobile nodes. The scheme also involves dynamic changes of these local constraints through negotiation, which we call re-localization. To overcome the problem of simultaneous requests for such re-localization, we give algorithms along with experimental results indicating their effectiveness.

XML is becoming a standard for information representation and exchange for electronic and mobile commerce. While almost all of these applications require an XML storage, e.g., for managing their transaction data, messages, or metadata, low-cost XML database management systems are not widely available. In particular, for mobile commerce, most of these databases are not designed for handling mobile XML data and messages. This paper describes an XML database engine that can be easily built on top of any existing RDBMS such as an open source, free relational database and performs efficiently. It has also been designed such that large databases can be partitioned, stored in multiple mobile devices and yet viewed as a single source with data transmitting in an efficient and seamless manner.

XML is becoming a standard for information representation and exchange for electronic and mobile commerce. While almost all of these applications require an XML storage, e.g., for managing their transaction data, messages, or metadata, low-cost XML database management systems are not widely available. In particular, for mobile commerce, most of these databases are not designed for handling mobile XML data and messages. This paper describes an XML database engine that can be easily built on top of any existing RDBMS such as an open source, free relational database and performs efficiently. It has also been designed such that large databases can be partitioned, stored in multiple mobile devices and yet viewed as a single source with data transmitting in an efficient and seamless manner.

To allow mobile users to continue their work while disconnected, mobile systems usually rely on optimistic replication techniques. In mobile database systems, mobile units cache subsets of the database state and allow disconnected users to perform transactions concurrently. These transactions are later integrated in the master database state. As concurrently performed transactions may conflict, it is usually impossible to determine the result of an update in the mobile unit. Moreover, this model differs from the traditional client/server model due to the fundamental fact that the user will usually not be connected to the system when the results of his transactions are finally determined-therefore, he can not immediately perform adequate alternative actions. In this paper we describe a transaction management system that takes into consideration the above-mentioned characteristics. Transactions are specified as mobile transactional programs, which allows the precise definition of operation semantics and the definition of alternative actions. Support for active user notification is also provided in the system. Finally, the system relies on a reservation mechanism to be able to guarantee the results of transactions in the mobile units.

This paper descrbes two protocols for the detection of deadlocks in distributed data bases-a hierarchically organized one and a distributed one. A graph model which depicts the state of execution of all transactions in the system is used by both protocols. A cycle in this graph is a necessary and sufficient condition for a deadlock to exist. Nevertheless, neither protocol requires that the global graph be built and maintained in order for deadlocks to be detected. In the case of the hierarchical protocol, the communications cost can be optimized if the topology of the hierarachy is appropriately chosen.

Today, Cloud computing is most widely used system due to number of benefits to end users. In IT (Information Technology) organizations, cloud computing is most vital domain to work. There are different types of services such as SaaS, IaaS and PaaS provided by cloud computing based on the end users needs. Rather than using own resources for data storage and Management, organizations started to utilize cloud computing data storage systems. Cloud storage (eg. Amazon S3) is emerging as a popular service and most of the enterprises shifts their data workloads to the cloud. The popularity of Cloud computing system increased dramatically because it rent computing resources, bill on a pay-as-you-go basis and multiplex many users on same physical infrastructure. Cloud users are provided an illusion of infinite computing resources so that on demand resource consumption rate can be increased or decreased. Cloud computing offers the vision of a virtually infinite pool of computing, storage and ...

We propose a consistency model for a data store in the Cloud and work towards the goal of deploying Database as a Service over the Cloud. This includes consistency across the data partitions and consistency of any replicas that exist across different nodes in the system. We target applications which need stronger consistency guarantees than the applications currently supported by the data stores on the Cloud. We propose a cost-effective algorithm that ensures distributed consistency of data without really compromising on availability for fully replicated data. This paper describes a design in progress, presents the consistency and recovery algorithms for relational data, highlights the guarantees provided by the system and presents future research challenges. We believe that the current notions of consistency for databases might not be applicable over the Cloud and a new formulation of the consistency concept may be needed keeping in mind the application classes we aim to support.

The work described in this article arises from two needs. First, there is still a need for providing more sophisticated database systems than just relational ones. Secondly, there is a growing need for distributed databases. These needs are addressed by fragmenting schemata of a generic object data model and providing an architecture for its implementation. Key features of the architecture are the use of abstract communicating agents to realise database transactions and queries, the use of a remote object call mechanism to enable remote agents to communicate with one another, and the use of multilevel transactions. Linguistic reflection is used to map database schemata to the level of the agents. Transparency for the users is achieved by using dialogue objects, which are extended views on the database.

This study discusses the main relevant use of Java in keeping the payment gateways' transaction security and integrity stable. Various security measures, authentication and authorization procedures, Java features, frameworks and libraries, transaction management protocols, scalability and performance mechanisms, compliance regulation, integration with external services, system monitoring, and logging, and emerging trends are closely studied, and their influence on the resiliency and reliability of these systems is analyzed. This paper consolidates existing research concerning the technology used in credit card-integrated payment gateways through a systematic literature review, industry practice, and case studies. In order to better understand the techniques applied to ensure transactional integrity and security, it covers several aspects like framework choice, security protocols, scalability, and compliance. As it is clear from the outcomes, Java is an essential aspect of developing a payment gateway as it provides a wide window of opportunity for integration of the most up-todate security features, flawless transaction processing, and scalable design. It also focuses on how Java can be used to satisfy the laws and policies as well as to foresee future trends and accommodate them accordingly. This study contributes to the theoretical understanding of the role Java plays in financial payment gateways by offering fine viewpoints on pragmatic implementations and their effects on policy framing within the financial services industry. The article brings to light the meaning of the role of Java in securing and maintaining the integrity of transactions for the benefit of digital payment industries by helping firms improve the credibility of their services among clients.

Patterns and Pattern Languages are ways to capture experience and make it reusable for others, and describe best practices and good designs. Patterns are solutions to recurrent problems. This paper addresses the database integrity problems from a pattern perspective. Even if the number of vendors of database management systems is quite high, the number of available solutions to integrity problems is limited. They all learned from the past experience applying the same solutions over and over again. The solutions to avoid integrity threats applied to in database management systems (DBMS) can be formalized as a pattern language. Constraints, transactions, locks, etc, are recurrent integrity solutions to integrity threats and therefore they should be treated accordingly, as patterns.

Transaction is an important concept in the database systems, it moves the database from consistent state to a new consistent state, so that users trust the information retrieved from information systems. A mobile user usually works offline, when connecting to the system, he needs to synchronize his work with the primary database server and updates his local copy, but database may be changed while he is working offline. In this paper we introduce the M-Shadow-Agent model which is a modification of the M-Shadow technique to avoid mobile disconnection problems and handling data changing problem while the mobile user is disconnected or working offline, by using the actionability and the business rules. It increases the transaction success probability, and reserves database consistency. In this paper, the solution concerns on avoiding disconnection, and transaction is not divisible and transaction is one compound transaction only.

Distributed systems with a centralized architecture present the well known problems of single point of failure and single point of congestion; therefore, they do not scale. Decentralized systems, especially as peer-to-peer networks, are gaining popularity because they scale well, and do not need a server to work. However, their complexity is higher due to the lack of a single point of control and synchronization, and because consistent decentralized storage is difficult to maintain when data constantly evolves. Self-management is a way of handling this higher complexity. In this paper, the authors present a decentralized system built with a structured overlay network that is self-organized and self-healing, providing a transactional replicated storage for small or large scale systems.

In this paper we consider mechanisms for supporting recoverable-persistence in a single address space memory model. In particular, we consider a memory management system, MMS, for a persistent single address space and show how the operations MMS supplies can be exploited by applications to make their state recoverable-persistent. To this end, we present detailed examples of application-level management of recoverable-persistence. The resulting scenario appears to be particularly attractive because of its modularity. Moreover, additional complexity is not introduced at the lower layers of the system and applications that do not need recoverable-persistence need not be penalised. ᭧ 1998 Elsevier Science B.V.

Peut-être aimez-vous à retrouver dans votre lit, après une journée harassante, votre oreiller à mémoire de forme? Ces oreillers contiennent généralement du polyuréthane qui leur permet de reprendre leur forme originelle après qu'on se soit amusé à les plier dans tous les sens. Nous allons voir dans la suite que l'oreiller à mémoire de forme peut être compris comme une allégorie de l'autostabilisation, un concept fondamental de l'algorithmique distribuée ; grosso modo, l'algorithmique dédiée aux réseaux informatiques. Pour cela, détaillons un exemple illustratif. Considérons un programme P contenant une unique variable entière (strictement) positive v. Cette variable est initialisée de manière quelconque (au hasard, par exemple). Le code de P consiste à appliquer itérativement l'algorithme suivant : si v est paire alors divisons v par deux sinon multiplions v par trois puis ajoutons-lui un. Observons maintenant une exécution de notre programme, c'est-à-dire l'évolution dans le temps de son état, une photographie du système à un instant donné. Ici, l'exécution correspond à la suite des valeurs prises par v. Par exemple, si nous fixons la valeur initiale de v à 12, on obtient la séquence infinie

A stable heap is storage that is managed automatically using garbage collection, manipulated using atomic transactions, and accessed using a uniform storage model. These featnres enhance reliability and simplify programming by preventing errors due to explicit deallocation, by masking failures and concurrency using transactions, and by eliminating the distinction between accessing temporary storage and permanent storage. Stable heap management is useful for programming languages for reliable distributed computing, programming languages with persistent storage, and object+riented database systems. Many applications that could benefit from a stable heap (e.g., computer-aided design, computer-aided software engineering, and office information systems) require large amounts of storage, timely responses for transactions, and high availability. We present garbage collection and recovery algorithms for a stable heap implementation that meet these goals and are appropriate for stock hardware. The collector is incremental it does not attempt to collect the whole heap at once. The collector is also atomic: it is coordinated with the recovery system to prevent problems when it moves and modifies objects. The time for recovery is independent of heap size, even if a failure occurs during garbage collection.

We introduce TxFS, a novel transactional file system that builds upon a file system's atomic-update mechanism such as journaling. Though prior work has explored a number of transactional file systems, TxFS has a unique set of properties: a simple API, portability across different hardware, high performance, low complexity (by building on the journal), and full ACID transactions. We port SQLite and Git to use TxFS, and experimentally show that TxFS provides strong crash consistency while providing equal or better performance.

The traditional wisdom for designing database schemas is to use a design tool (typically based on a UML or E-R model) to construct an initial data model for one's data. When one is satisfied with the result, the tool will automatically construct a collection of 3rd normal form relations for the model. Then applications are coded against this relational schema. When business circumstances change (as they do frequently) one should run the tool again to produce a new data model and a new resulting collection of tables. The new schema is populated from the old schema, and the applications are altered to work on the new schema, using relational views whenever possible to ease the migration. In this way, the database remains in 3rd normal form, which represents a "good" schema, as defined by DBMS researchers. "In the wild", schemas often change once a quarter or more often, and the traditional wisdom is to repeat the above exercise for each alteration. In this paper we report that the traditional wisdom appears to be rarely-to-never followed for large, multi-department applications. Instead DBAs appear to attempt to minimize application maintenance (and hence schema changes) instead of maximizing schema quality. This leads to schemas which quickly diverge from E-R or UML models and actual database semantics tend to drift farther and farther from 3rd normal form. We term this divergence of reality from 3rd normal form principles database decay. Obviously, this is a very undesirable state of affairs, and should be avoided if possible. The paper continues with tactics to slow down database decay. We argue that the traditional development methodology, that of coding applications in ODBC or JDBC, is at least partly to blame for decay. Hence, we propose an alternate methodology that should be more resilient to decay.