Programming Language Features Research Articles

Develop a Program Design and Coding Standard

The use of programming language is increasing in the real world in all domains. So it’s important to follow and maintain coding guidelines & standard and follow the best practice. This article gives an overview of naming & coding standard, use of it, comparison of the main features of different programming languages(C++, Java, Python), data management approaches for local, mobile and cloud solutions for ERP and EHR implementations, the structure of each proposed algorithm and use, Few examples for in-house development, ERP solutions, packaged software implementations, and mobile applications, few proposals, and recommendations for further research. Also explain how to create the corporate standards a sample database and application design and development.

An Iris Instance for Verifying CompCert C Programs

Iris is a generic separation logic framework that has been instantiated to reason about a wide range of programming languages and language features. Most Iris instances are defined on simple core calculi, but by connecting Iris to new or existing formal semantics for practical languages, we can also use it to reason about real programs. In this paper we develop an Iris instance based on CompCert, the verified C compiler, allowing us to prove correctness of C programs under the same semantics we use to compile and run them. We take inspiration from the Verified Software Toolchain (VST), a prior separation logic for CompCert C, and reimplement the program logic of VST in Iris. Unlike most Iris instances, this involves both a new model of resources for CompCert memories, and a new definition of weakest preconditions/Hoare triples, as the Iris defaults for both of these cannot be applied to CompCert as is. Ultimately, we obtain a complete program logic for CompCert C within Iris, and we reconstruct enough of VST's top-level automation to prove correctness of simple C programs.

Automatic Generation of Network Function Accelerators Using Component-Based Synthesis

The document discusses the development of a compiler called SyNAPSE, which aims to address the challenge of programming for multiple hardware targets in networked systems. It focuses on optimising the performance, efficiency, and resource consumption of networked systems by dividing packet processing across multiple hardware platforms. The key problem it is solving is the difficulty in developing high-performance network functions for multiple platforms, each with its own programming language and hardware features. SyNAPSE aims to provide a solution that allows for 'write once, run anywhere' code that is portable across different platforms and automatically provisioned on the hardware best- suited for the task. It explores a large search space of different mappings of functionality to hardware, allowing for optimization based on programmer- specified objectives such as minimising memory consumption or maximising network throughput.

Synchronization Possibilities and Features in Java

Abstract In this paper we have discussed one of the greatest features of the general-purpose computer programming language –Java. This paper represents concepts of Synchronization possibilities and features in Java. Today’s operating systems support concept of “Multitasking”. Multitasking achieved by executing more than one task at a same time. Tasks runs on threads. Multitasking runs more than one task at a same time. Multitasking which means doing many things at the same time is one of the most fundamental concepts in computer engineering and computer science because the processor execute given tasks in parallel so it makes me think that are executing simultaneously. Multitasking is related to other fundamental concepts like processes and threads. A process is a computer program that is executing in a processor, while a thread is a part of a process that has a way of execution: it is a thread of execution. Every process has at least one thread of execution. There are two types of multitasking: process – based and thread – based. Process-based multitasking, means that on a given computer there can be more than one program or process that is executing, while thread-based multitasking, which is also known as multithreading, means that within a process, there can be more than one thread of execution, each of them doing a job and so accomplishing the job of their process. When there are many processes or many threads within processes, they may have to cooperate with each other or concurrently try to get access to some shared computer resources like: processor, memory and input/output devices. They may have to, for example: print a file in a printer or write and/or read to the same file. We need a way of setting an order, where processes and/or threads could do their jobs (user jobs) without any problem, we need to synchronize them. Java has built-in support for process and thread synchronization, there are some constructs that we can use when we need to do synchronization.This paper, a first phase discussed the concept of Parall Programming, threads, how to create a thread, using a thread, working with more than one thread. Second phase is about synchronization, what is in general and in the end we disscused the synchronization possibilities and feautures in Java.

Method of generating ORM models software code based on relational database schemes

Abstract. Problem. Databases and data stores are an important part of any system, regardless of the field of application. It is at this level that all system information is stored, such as a list of online store products, user personal data, system configuration parameters, etc. In addition, they allow to structure information in the desired format. Although the use of databases is associated with obvious advantages, it has some disadvantages, in particular the process of designing them and integrating their software code is labor-intensive and time-consuming. This problem is usually attempted to be circumvented by using ORM libraries, which provide a convenient programming interface for performing basic queries. But the process of setting up an ORM library including developing ORM models still takes a lot of time. Goal. The purpose of the work is to develop an algorithm for the automatic generation of software code for ORM models based on the selected ORM library and the data scheme presented in the form of a configuration file. To achieve the goal, it is necessary to establish the optimal representation of the data scheme in text format, to determine the structure of the data configuration scheme and to describe all stages of the generation of software code for ORM models. Methodology. System approach, analysis of existing methods of visual design, formats of text representation of configuration data and methods of configuration data storing. Results. The developed method for software code generation for the selected ORM library based on the scheme of the relational database provides the user with the opportunity to obtain a qualitatively designed software code with minimal time expenditure. Originality. The developed method implements a unique approach which allows to create program code for various ORM libraries, supports the syntax and features of a specific programming language, and provides work with data schemas from various relational databases. Practical value. Developed generation algorithm can be used as part of the software in which the automated process of preparing the data schema in the appropriate text formatted form will be implemented. As a result, such a web-application will represent a platform for working with the data layer for IT professionals.

Rigorous Pattern Matching as a Language Feature

Structural pattern-matching as a language feature has become more common in programming languages over the past decade. This paper will consider more generally the challenge of adding pattern matching as a programming language feature, from the points of view of language design, rigorous static error detection, and effectiveness. In this context, a pattern matching language feature can be seen as providing a more rigorous approach to handling the complex conditionals that arise in processing highly structured input.

Recursive Subtyping for All

Recursive types and bounded quantification are prominent features in many modern programming languages, such as Java, C#, Scala or TypeScript. Unfortunately, the interaction between recursive types, bounded quantification and subtyping has shown to be problematic in the past. Consequently, defining a simple foundational calculus that combines those features and has desirable properties, such as decidability , transitivity of subtyping, conservativity and a sound and complete algorithmic formulation has been a long time challenge. This paper presents an extension of kernel ‍ F ≤ , called F ≤ µ , with iso-recursive types. F ≤ is a well-known polymorphic calculus with bounded quantification. In F ≤ µ we add iso-recursive types, and correspondingly extend the subtyping relation with iso-recursive subtyping using the recently proposed nominal unfolding rules. We also add two smaller extensions to F ≤ . The first one is a generalization of the kernel ‍ F ≤ rule for bounded quantification that accepts equivalent rather than equal bounds. The second extension is the use of so-called structural folding/unfolding rules, inspired by the structural unfolding rule proposed by Abadi, Cardelli, and Viswanathan [1996]. The structural rules add expressive power to the more conventional folding/unfolding rules in the literature, and they enable additional applications. We present several results, including: type soundness; transitivity and decidability of subtyping; the conservativity of F ≤ µ over F ≤ ; and a sound and complete algorithmic formulation of F ≤ µ . Moreover, we study an extension of F ≤ µ , called F ≤≥ µ , which includes lower bounded quantification in addition to the conventional (upper) bounded quantification of F ≤ . All the results in this paper have been formalized in the Coq theorem prover.

Why Did Developers Migrate Android Applications From Java to Kotlin?

Currently, the majority of apps running on mobile devices are Android apps developed in Java. However, developers can now write Android applications using a new programming language: Kotlin, which Google adopted in 2017 as an official programming language for developing Android apps. Since then, Android developers have been able to: a) start writing Android applications from scratch using Kotlin, b) evolve their existing Android applications written in Java by adding Kotlin code (possible thanks to the interoperability between the two languages), or c) migrate their Android apps from Java to Kotlin. This paper aims to study this last case. We conducted a qualitative study to find out <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">why</i> Android developers have migrated Java code to Kotlin and to bring together their experiences about the process, in order to identify the main difficulties they have faced. To execute the study, we first identified commits from open-source Android projects that have migrated Java code to Kotlin. Then, we emailed the developers that wrote those migrations. We thus obtained information from 98 developers who had migrated code from Java to Kotlin. This paper presents the main reasons identified by the study for performing the migration. We found that developers migrated Java code to Kotlin in order to access programming language features (e.g., extension functions, lambdas, smart casts) that are not available with Java for Android development, and to obtain safer code (i.e., avoid null-pointer exceptions). We also identified research directions that the research community could focus on in order to help developers to improve the experience of migrating their Java applications to Kotlin.

A conceptual framework for safe object initialization: a principled and mechanized soundness proof of the Celsius model

An object under initialization does not fulfill its class specification yet and can be unsafe to use as it may have uninitialized fields. It can sometimes be useful to call methods on such a partially initialized object in order to compute a complex initial value, or to let the object escape its constructor in order to create mutually recursive objects. However, inadvertent usage of uninitialized fields can lead to run-time crashes. Those subtle programming errors are not statically detected by most modern compilers. While many other features of object-oriented programming languages have been thoroughly studied over the years, object initialization lacks a simple, systematic, and principled treatment. Building on the insights of previous work, we identify a set of four core principles for safe initialization: monotonicity, authority, stackability, and scopability. We capture the essence of the principles with a minimal calculus, Celsius, and show that the principles give rise to a practical initialization system that strikes a balance between expressiveness and simplicity. The meta-theory of the system is entirely mechanized using the Coq proof assistant. We believe that our approach based on well-identified core principles sheds new light on the underlying mechanisms ensuring safety and could serve as a basis for language design when faced with similar challenges.

Python- An Appetite for the Software Industry

Python is a scripting language that's high- positioned, interpreted, interactive, and object- oriented. Python is intended to be a veritably accessible programming language. It generally uses English terms rather than punctuation, and it has smaller syntactical structures than other languages. Python is a must-have skill for scholars and working professionals who want to become exceptional software masterminds, especially if they work in the web development field. It's a freshman-friendly scripting language. Some of the crucial features of Python programming language are- It supports OOP as well as functional and structured programming methodologies. It can be used as a scripting language or collected into bytecode for large-scale operations. It allows dynamic type verification and provides veritably high-position dynamic data types. It facilitates scrap collection by itself. Numerous different programming languages have been impacted by Python's design and gospel. Some of those languages are Boo, Cobra, CoffeeScript, Go, Swift, Ruby, etc. Some of the advantages of Python programming language are straightforward, free, simple to use, and largely compatible, object- acquainted, has multitudinous libraries, has erected in data structures, has a wide range of uses, boosts productivity and speed, and simple to understand. One of the most extensively used programming languages is Python. It's an open- source language. Python's demand is growing, and its operations are expanding in virtually every assiduity. It's abundant in every way. It has a wide range of capabilities. Python is a popular programming language. It's also developing a strong request in the IT sector. Python is in high demand across the globe. Python helps you negotiate more in lower time. Python has a large community that supports and meets the requirements of inventors. Python is therefore one of the most popular programming languages. It's a veritably reliable and effective programming language. Python programmers are in high demand because Python is being used in a variety of sectors. Python is an extensively used computer language that was created nearly 25 years ago. Python is useful in a variety of fields, including web development, desktop app development, machine literacy, big data, data analysis, and robotics. Clean syntax, extremely clear law, a wide range of uses, packages that help apply features, and a cool community that helps grow this excellent language are just a many of the reasons why people like this language and why it's well suited for different tasks. The Python programming language has a bright future. The advanced technologies like Artificial Intelligence, Machine Learning, Big Data, Cloud Computing, Data Science, etc and world-notorious companies similar as Amazon, Google, Apple, Deloitte, Microsoft, Netflix, and Accenture have the Python programming language as their backbone which states that Python is in demand and AN APPETITE FOR THE SOFTWARE INDUSTRY! A standard and scientific procedure of an Empirical Exploration Methodology (Survey) was conducted to check the statement stated by the author where 900 repliers from colourful corridors of the globe shared their thoughts. From the check, it was concluded that 99.8% of the respondents feel that Python is one of the in- demand programming languages for the digital assiduity in the present time.

Can guided decomposition help end-users write larger block-based programs? a mobile robot experiment

Block-based programming environments, already popular in computer science education, have been successfully used to make programming accessible to end-users in domains like robotics, mobile apps, and even DevOps. Most studies of these applications have examined small programs that fit within a single screen, yet real-world programs often grow large, and editing these large block-based programs quickly becomes unwieldy. Traditional programming language features, like functions, allow programmers to decompose their programs. Unfortunately, both previous work, and our own findings, suggest that end-users rarely use these features, resulting in large monolithic code blocks that are hard to understand. In this work, we introduce a block-based system that provides users with a hierarchical, domain-specific program structure and requires them to decompose their programs accordingly. Through a user study with 92 users, we compared this approach, which we call guided program decomposition, to a traditional system that supports functions, but does not require decomposition. We found that while almost all users could successfully complete smaller tasks, those who decomposed their programs were significantly more successful as the tasks grew larger. As expected, most users without guided decomposition did not decompose their programs, resulting in poor performance on larger problems. In comparison, users of guided decomposition performed significantly better on the same tasks. Though this study investigated only a limited selection of tasks in one specific domain, it suggests that guided decomposition can benefit end-user programmers. While no single decomposition strategy fits all domains, we believe that similar domain-specific sub-hierarchies could be found for other application areas, increasing the scale of code end-users can create and understand.

On the use of generic types for smart contracts

This paper shows that generic types (generics) are useful for writing more abstract and more general smart contracts, but this comes with some security risks, reporting a concrete security issue found while using generics for writing smart contracts that implement shared entities for the Hotmoka blockchain. That issue can be used to steal the remuneration of validator nodes. This paper proposes a patch based on appropriate code rewriting. Namely, smart contracts are pieces of code that are deployed and executed in the context of a blockchain infrastructure in order to automatically enforce some effects when particular events occur. The writing of smart contracts is a complex and critical activity that can benefit from the use of high-level features of programming languages, and generics is one of them. In many programming languages, such as Java, generics are implemented by erasure, i.e. replaced by their upper bound type during compilation into bytecode. This is safe at source level, since the compiler takes care of checking that types are correct, before erasure. However, the erased types of the generated bytecode are consequently weaker. In a permissionless blockchain, where every user can call the bytecode of smart contracts installed by other users, these weaker types pose a risk of attack.

A Generalized Search Construct for Imperative Languages to Facilitate Declarative Programming

Search is one of the more common strategies used by problem-solving agents. For many hard problems, a backtracking search can be the most effective approach for finding a solution. Logic programming languages provide, as a core feature of the language, the mechanics for the search behind the scenes without requiring the user to specify the algorithm. However, this functionality has been generally left out of the core features of imperative programming languages. In this work, we propose integrating a search agent into an imperative programming language through a search construct in the syntax. By doing so, our intention is that the user may apply a declarative approach to problem solving. We extend the Go programming language with this search construct and develop an agent to perform the search. The algorithm behind the search is implicitly handled by the agent. We demonstrate the effectiveness of this search construct through solutions to an exhaustive search over a file-system, the NQueens problem, and the monkey and the bananas problem. To evaluate the performance of our agent, we compare its runtime performance against two of the common Prolog implementations, SWI-Prolog and GNU Prolog.

Задача анализа эмоциональной окраски текстов в банковской деятельности

The paper presents the author's approach to solving the problem of sentiment analysis of online Russian-language messages about the activities of banks. The study data are customer reviews about banks in general and their products, services and quality of service posted on the Banki.ru portal. In this paper, the problem of text sentiment analysis is considered as a binary classification task based on a set of positive and negative reviews. A vector model with a tf-idf weighting scheme was used to represent the collected and preprocessed texts. The following algorithms with the selection of optimal parameters on the grid were used for binary classification task: naive Bayesian classifier, support vector machine, logistic regression, random forest and gradient boosting. Standard statistical metrics, such as accuracy, completeness, and F-measure, were used to evaluate the quality of solving the classification problem. For the indicated metrics, the best results were obtained on the classification model developed with the use of Support Vector Machine. Thematic text modeling was also carried out using the Dirichlet latent placement method to define the most typical topics of customer messages. As a result, it was concluded that the most popular message topics are "cards" and "quality of service". The obtained results can be used in the activities of banks to automate its reputation monitoring in the media and when routing client requests to solve various problems. When solving problems, the features of the Python programming language were actively used, namely, libraries for web scraping, machine learning, and natural language processing.

MOBILE APP DEVELOPMENT TO INCREASE STUDENT ENGAGEMENT AND PROBLEM SOLVING SKILLS USING ANDROID TECHNOLOGY

Programming is a fundamental ability for Computer Science Students. Most programming lectures use traditional languages, such as C, C++, or Java, as the rst learning language for beginners, which are effective for real applications and therefore are popular in industry. However, the complex syntax of these languages is challenging for beginners, which becomes an obstacle to their learning. Python has simpler syntax and high-level data structures to enable succinct programs. The multiple paradigms of Python also provide learners opportunities to learn various features of programming languages. Therefore, Python gradually becomes a new option of the rst language for learning. This Project investigates the features of the rst learning programming language by comparing Python with the popular learning language Java. The results has given instructors suggestions for selecting suitable learning languages in their lectures and designing adaptive instructional strategies/materials based on the features of the selected language.

Efficient compilation of algebraic effect handlers

The popularity of algebraic effect handlers as a programming language feature for user-defined computational effects is steadily growing. Yet, even though efficient runtime representations have already been studied, most handler-based programs are still much slower than hand-written code. This paper shows that the performance gap can be drastically narrowed (in some cases even closed) by means of type-and-effect directed optimising compilation. Our approach consists of source-to-source transformations in two phases of the compilation pipeline. Firstly, elementary rewrites, aided by judicious function specialisation, exploit the explicit type and effect information of the compiler’s core language to aggressively reduce handler applications. Secondly, after erasing the effect information further rewrites in the backend of the compiler emit tight code. This work comes with a practical implementation: an optimising compiler from Eff, an ML style language with algebraic effect handlers, to OCaml. Experimental evaluation with this implementation demonstrates that in a number of benchmarks, our approach eliminates much of the overhead of handlers, outperforms capability-passing style compilation and yields competitive performance compared to hand-written OCaml code as well Multicore OCaml’s dedicated runtime support.

The Specification Language Server Protocol: A Proposal for Standardised LSP Extensions

The Language Server Protocol (LSP) changed the field of Integrated Development Environments(IDEs), as it decouples core (programming) language features functionality from editor smarts, thus lowering the effort required to extend an IDE to support a language. The concept is a success and has been adopted by several programming languages and beyond. This is shown by the emergence of several LSP implementations for the many programming and specification languages (languages with a focus on modelling, reasoning, or proofs). However, for such languages LSP has been ad-hocly extended with the additional functionalities that are typically not found for programming languages and thus not supported in LSP. This foils the original LSP decoupling goal, because the move towards a new IDE requires yet another re-implementation of the ad-hoc LSP extension. In this paper we contribute with a conservative extension of LSP providing a first proposal towards a standard protocol decoupling the support of specification languages from the IDE. We hope our research attracts the larger community and motivates the need of a joint task force leading to a standardised LSP extension serving the particular needs of specification languages.

Cross-tier Web Programming for Curated Databases: a Case Study

Curated databases have become important sources of information across several scientific disciplines, and as the result of manual work of experts, often become important reference works. Features such as provenance tracking, archiving, and data citation are widely regarded as important features for the curated databases, but implementing such features is challenging, and small database projects often lack the resources to do so.&#x0D; A scientific database application is not just the relational database itself, but also an ecosystem of web applications to display the data, and applications which allow data curation. Supporting advanced curation features requires changing all of these components, and there is currently no way to provide such capabilities in a reusable way.&#x0D; Cross-tier programming languages allow developers to write a web application in a single, uniform language. Consequently, database queries and updates can be written in the same language as the rest of the program, and it should be possible to provide curation features via program transformations. As a step towards this goal, it is important to establish that realistic curated databases can be implemented in a cross-tier programming language.&#x0D; In this article, we describe such a case study: reimplementing the web frontend of a realworld scientific database, the IUPHAR/BPS Guide to PHARMACOLOGY (GtoPdb), in the Links cross-tier programming language. We show how programming language features such as language-integrated query simplify the development process, and rule out common errors. Through an automated functional correctness evaluation, we show that the Links implementation correctly implements the functionality of the official version. Through a comparative performance evaluation, we show that the Links implementation performs fewer database queries, while the time neededto handle the queries is comparable to the official Java version. Furthermore, while there is some overhead to using Links because of its comparative immaturity compared to Java, the Links version is usable as a proof-of-concept case study of cross-tier programming for curated databases.

Lolisa: Formal Syntax and Semantics for a Subset of the Solidity Programming Language in Mathematical Tool Coq

The security of blockchain smart contracts is one of the most emerging issues of the greatest interest for researchers. This article presents an intermediate specification language for the formal verification of Ethereum-based smart contract in Coq, denoted as Lolisa. The formal syntax and semantics of Lolisa contain a large subset of the Solidity programming language developed for the Ethereum blockchain platform. To enhance type safety, the formal syntax of Lolisa adopts a stronger static type system than Solidity. In addition, Lolisa includes a large subset of Solidity syntax components as well as general-purpose programming language features. Therefore, Solidity programs can be directly translated into Lolisa with line-by-line correspondence. Lolisa is inherently generalizable and can be extended to express other programming languages. Finally, the syntax and semantics of Lolisa have been encapsulated as an interpreter in mathematical tool Coq. Hence, smart contracts written in Lolisa can be symbolically executed and verified in Coq.

Igloo: soundly linking compositional refinement and separation logic for distributed system verification

Lighthouse projects like CompCert, seL4, IronFleet, and DeepSpec have demonstrated that full system verification is feasible by establishing a refinement between an abstract system specification and an executable implementation. Existing approaches however impose severe restrictions on the abstract system specifications due to their limited expressiveness or versatility, or on the executable code due to their use of suboptimal code extraction or inexpressive program logics. We propose a novel methodology that combines the compositional refinement of event-based models of distributed systems with the verification of full-fledged program code using expressive separation logics, which support features of realistic programming languages like heap data structures and concurrency. Our main technical contribution is a formal framework that soundly relates event-based system models to program specifications in separation logics. This enables protocol development tools to soundly interoperate with program verifiers to establish a refinement between the model and the code. We formalized our framework, Igloo, in Isabelle/HOL. We report on three case studies, a leader election protocol, a replication protocol, and a security protocol, for which we refine formal requirements into program specifications that we implement in Java and Python and prove correct using the VeriFast and Nagini tools.