Immutable Data Structures Research Articles

A Framework To Make Voting System Transparent Using Blockhain Technology

Generally, governments release schemes or plans like roadways or industries to some area as different projects. During this process, different types of peoples will be there as supportive or opponent for the schemes. In this project, we presented a secure and transparent framework for government schemes using blockchain. Blockchain is used as a secure and immutable data structure to store the government records that are highly susceptible to tampering. Here, we aim to address these issues to build a transparent and secure edge computing infrastructure for the allocation of government schemes which not only eliminates the need for human supervision or intervention but also makes it easy for the government to keep track and update its policies as time progresses. To solve this issue, we propose the framework to use blockchain technology for creating a decentralized system to perform government scheme processes with ease, transparent, auditable, and immutable. The proposed model consists of a decentralized consortium architecture that combines both the security and privacy of a Permissioned Blockchain and the openness and transparency of a Permission-less Blockchain. The target of the model is to efficiently handle the government tender process securely. The system mainly consists of three types of entities: government officials, citizens and schemes.

Exploring the Next Wave of Blockchain and Distributed Ledger Technology: The Overlooked Potential of Scenario Analysis

Blockchain is predicted to disrupt industries, economies, and societies. The properties of distributed ledgers allow the creation of immutable data structures that facilitate shared access in real time and enable a plethora of innovative applications. However, blockchain is not a uniform technology but rather a bundle of evolving components whose implications are notoriously hard to predict. At present, it is not clear how current trends will evolve, with technical evolution, legislation, and public policy being three contingency factors that make ongoing disruptive transformations particularly hard to predict. In light of blockchain’s potential disruptive impact, it is surprising that scenario analysis has hitherto been largely ignored in academic research. Therefore, in this paper, we introduce the technique, clarify several misconceptions, and provide examples illustrating how this method can help to overcome the limitations of existing technology impact research. We conclude that if applied correctly, scenario analysis represents the ideal tool to rigorously explore uncertain future developments and to create a comprehensive foundation for future research.

A Blockchain and Edge-Computing-Based Secure Framework for Government Tender Allocation

Governments and public sector entities around the world are actively exploring new ways to keep up with technological advancements to achieve smart governance, work efficiency, and cost optimization. Blockchain technology is an example of such technology that has been attracting the attention of Governments across the globe in recent years. Enhanced security, improved traceability, and lowest cost infrastructure empower the blockchain to penetrate various domains. Generally, governments release tenders to some third-party organizations for different projects. During this process, different competitors try to eavesdrop the tender values of others to win the tender. The corrupt government officials also charge high bribe to pass the tender in favor of some particular third party. In this article, we presented a secure and transparent framework for government tenders using blockchain. Blockchain is used as a secure and immutable data structure to store the government records that are highly susceptible to tampering. This work aims to create a transparent and secure edge computing infrastructure for the workflow in government tenders to implement government schemes and policies by limiting human supervision to the minimal.

Implementation of a MIX Emulator: A Case Study of the Scala Programming Language Facilities

Abstract Implementation of an emulator of MIX, a mythical computer invented by Donald Knuth, is used as a case study of the features of the Scala programming language. The developed emulator provides rich opportunities for program debugging, such as tracking intermediate steps of program execution, an opportunity to run a program in the binary or the decimal mode of MIX, verification of correct synchronisation of input/output operations. Such Scala features as cross-compilation, family polymorphism and support for immutable data structures have proved to be useful for implementation of the emulator. The authors of the paper also propose some improvements to these features: flexible definition of family-polymorphic types, integration of family polymorphism with generics, establishing full equivalence between mutating operations on mutable data types and copy-and-modify operations on immutable data types. The emulator is free and open source software available at www.mix-emulator.org.

Chemf: A purely functional chemistry toolkit

BackgroundAlthough programming in a type-safe and referentially transparent style offers several advantages over working with mutable data structures and side effects, this style of programming has not seen much use in chemistry-related software. Since functional programming languages were designed with referential transparency in mind, these languages offer a lot of support when writing immutable data structures and side-effects free code. We therefore started implementing our own toolkit based on the above programming paradigms in a modern, versatile programming language.ResultsWe present our initial results with functional programming in chemistry by first describing an immutable data structure for molecular graphs together with a couple of simple algorithms to calculate basic molecular properties before writing a complete SMILES parser in accordance with the OpenSMILES specification. Along the way we show how to deal with input validation, error handling, bulk operations, and parallelization in a purely functional way. At the end we also analyze and improve our algorithms and data structures in terms of performance and compare it to existing toolkits both object-oriented and purely functional. All code was written in Scala, a modern multi-paradigm programming language with a strong support for functional programming and a highly sophisticated type system.ConclusionsWe have successfully made the first important steps towards a purely functional chemistry toolkit. The data structures and algorithms presented in this article perform well while at the same time they can be safely used in parallelized applications, such as computer aided drug design experiments, without further adjustments. This stands in contrast to existing object-oriented toolkits where thread safety of data structures and algorithms is a deliberate design decision that can be hard to implement. Finally, the level of type-safety achieved by Scala highly increased the reliability of our code as well as the productivity of the programmers involved in this project.

Freedom before commitment

One of the main purposes of object initialisation is to establish invariants such as a field being non-null or an immutable data structure containing specific values. These invariants are then implicitly assumed by the rest of the implementation, for instance, to ensure that a field may be safely dereferenced or that immutable data may be accessed concurrently. Consequently, letting an object escape from its constructor is dangerous; the escaping object might not yet satisfy its invariants, leading to errors in code that relies on them. Nevertheless, preventing objects entirely from escaping from their constructors is too restrictive; it is often useful to call auxiliary methods on the object under initialisation or to pass it to another constructor to set up mutually-recursive structures. We present a type system that tracks which objects are fully initialised and which are still under initialisation. The system can be used to prevent objects from escaping, but also to allow safe escaping by making explicit which objects might not yet satisfy their invariants. We designed, formalised and implemented our system as an extension to a non-null type system, but it is not limited to this application. Our system is conceptually simple and requires little annotation overhead; it is sound and sufficiently expressive for many common programming idioms. Therefore, we believe it to be the first such system suitable for mainstream use.

Freedom before commitment

One of the main purposes of object initialisation is to establish invariants such as a field being non-null or an immutable data structure containing specific values. These invariants are then impl...

Partial evaluation of call-by-value λ-calculus with side-effects

We present a framework of an online partial evaluator for a call-by-value λ-calculus with destructive updates of data structures. It properly and correctly specializes expressions that contain side-effects, while preserving pointer equality, which is an important property for programs using updates. Our partial evaluator uses a side-effect analysis to extract immutable data structures and then performs an online specialization using preactions. Once mutable and immutable data structures are separated, partial evaluation is done in such a way that accesses to immutable ones are performed at specialization time, while accesses to mutable ones are residualized. For the correct residualization of side-effecting operations, preactions are used to solve various issues, including code elimination, code duplication, and execution order preservation. The preaction mechanism also enables us to reduce expressions that were residualized when the conventional let-expression approach of Similix was used. The resulting partial evaluator is simple enough to prove its correctness. Based on the framework, we have constructed a partial evaluator for Scheme, which is powerful enough to specialize fairly complicated programs with side-effects, such as an interpreter.