In this paper, we focus on the design of consensus algorithms for permission-based blockchains, i.e., private blockchains. In most consensus algorithms, blocks are proposed by a specific role called “leader”. In this paper, we introduce a new role called “witness” to supervise the leader. The presence of the witness facilitates the design of the consensus algorithm. We propose a witness-based consensus algorithm that guarantees safety and liveness. We implemented this consensus algorithm on Go Ethereum. The experimental result shows that in a blockchain where four nodes participate in the consensus process, we can achieve a throughput of 1000 transactions per second (TPS). Even if these four nodes are located on different continents, and one of them is faulty, we can still achieve a throughput of 300 TPS. Finally, we find that during the experiment, a significant portion of time is spent on activities other than the consensus task. The result suggests that to further increase the throughput of a private blockchain, the consensus task and non-consensus activities should be considered jointly.

In software as a service (SaaS) environments, designing a multi-tenant data architecture that supports shared database with custom extension is a non-trivial task. A general approach to support such an architecture is a middleware-level facility that supports the mapping of multiple single-tenant logical schemas in the application to one multi-tenant physical schema in the database. In this paper we follow this approach and report our preliminary results on the design and analysis of a query rewriting engine that can transparently transform tenant-specific logical queries into corresponding physical queries for Universal Table, a widely adopted and industry verified schema-mapping technique. A prototype and a sample SaaS application are implemented to verify the feasibility of the design of the query rewriting engine. Besides, performance analysis results that can be used to predict the overhead of schema-mapping in the engine are also reported.

Computation performed in many typical aspects involve side effects. In a purely functional setting, adding such aspects using techniques such as monadification will generally lead to crosscutting changes. This paper presents an approach to provide side-effecting aspects for purely lazy functional languages in a user transparent fashion. We propose a simple yet direct state manipulation construct for developing side-effecting aspects and devise a systematic monadification scheme to translate the woven code to a purely monadic style functional code.

Despite the built-in garbage collector, Java programs can still suffer the memory leak problem resulted from the unhealthy programming style of retaining unwanted references. This paper presents an aspect-based tool for assisting programmers in locating such references to fix the problem. This tool, FindLeaks, utilizes an aspect to collect memory consumption statistics and object references created during a program's execution and analyzes them for detecting memory leaks. The distinctive feature of FindLeaks is that it reports not only suspected classes of leaking objects but also where in the source the unwanted references were created. Besides, this paper also reports some preliminary experience with FindLeaks.

Separation of concerns is one of the main tenets of software engineering - allowing developers to reason about software systems in sensible portions, regardless which phase of the lifecycle they are working in. Many researchers in software engineering are actually in the field of aspect-orientation without realizing it.

Aspect-oriented programming (AOP) has been shown to be a useful model for software development. Special care must be taken when we try to adapt AOP to strongly typed functional languages which come with features like a type inference mechanism, polymorphic types, higher-order functions and type-scoped pointcuts. Our main contribution lies in a seamless integration of these two paradigms through a static weaving process which deals with around advices with type-scoped pointcuts in the presence of higher-order functions. We give a source-level type inference system for a higher-order, polymorphic language coupled with type-scoped pointcuts. The type system ensures that base programs are oblivious to the type of around advices. We present a type-directed translation scheme which resolves all advice applications at static time. The translation removes advice declarations from source programs and produces translated code which is typable in the Hindley-Milner system.

This paper shows that a proper combination of instance-level aspects and dynamic deployment can be used to enhance an aspect-based access control system with dynamic and fine-grained delegation effectively in a highly modular manner. We developed a prototype implementation using the per instance interception mechanism of AspectWerkz. While workable, this mechanism still leaves much to be desired. We describe our implementation scheme and discuss the issues we encountered.

Most access control frameworks for Web application enforce the control along with the invocation of an application function. While effective for preventing unauthorized access, it also incurs certain runtime overhead and user inconvenience, for it is often possible to determine whether a particular function should be allowed without actually having to try to perform it. This paper presents a flexible function menu generator (F-menugen) that restricts user menus to functions that a user's current access-privileges permit, and can thus support access control on the presentation tier to overcome those shortcomings. The menu structure and rules governing the functions accessible to a user are specified declaratively in an XML configuration file; the rules are based on user attributes, application-specific requirements, and certain contextual information. This scheme retains the advantages of administrative scalability that role-based access control offers, yet provides the flexibility to specify more complex restrictions without actual coding.

This paper introduces, in a stepwise refinement manner, a new systolic array for solving simultaneous linear equations AX = B, where A is an n × n matrix and B is an n × m matrix. Instead of using conventional matrix triangularisation, our design is based on a generalised Gauss–Jordan elimination procedure. First A is transformed into a permutation matrix P and B is transformed into a matrix Q. Then X is computed by multiplying PT and Q. These two stages of computation are tightly pipelines to form an integrated systolic array which is capable of solving the simultaneous linear equations in just 6n + m − 2 time steps. This systolic array achieves maximum data pipelining rate and its computation time, in a sense, is optimal.

A systolic array for enumerating keys in n keys in 3n-1 time steps is introduced. This array has unidirectional data flow and achieves the maximum data pipelining rate. Modifications of the array for solving the closest-neighbor problems in computational geometry are presented.>