Strongly Typed Research Articles

ЯППИ – универсальный язык программирования миссий АНПА

This article proposes a universal language for developing autonomous underwater vehicle (AUV) missions. The main features of the proposed language are: the presence of high-level commands to describe the main tasks of underwater research, the use of commands in Russian, the readability of the created missions and their understandability for personnel involved in the use of underwater robotics, the lack of strict typing and parameterization of commands, the possibility of expanding the language by creating new commands based on the old ones. The article describes the main parameters of the language, syntax, semantics and basic commands, as well as language tools - a parameter refinement module, which interactively allows you to resolve uncertainty arising due to non-strict parameterization, low-level command module that implements more complex commands based on basic ones, a language extension module responsible for adding new commands, and a translator. The language translator allows you to translate created missions into task program codes for various AUVs. The created language is called URPL – Underwater Research Programming Language and at the current stage of research it is being tested and debugged on the AUVs of the IPMT FEB RAS, taking into account the experience accumulated at the institute.

A Fuzz Testing Approach for Embedded Avionic Software

The objective of the research was to find if it was possible to apply fuzz testing, a technique that can be used to test software to discover vulnerabilities, on an embedded avionic software using an open-source fuzz tool. The open-source fuzz tool AFL++ was applied to an NH90 Airbus Helicopter embedded software component to find the vulnerabilities. The proposed setup was able to find a few crashes related to data parsing associated with Ada strong typing declaration requirement. Moreover, the experiments outline practical guidelines and considerations for implementing fuzz testing on embedded avionic software.

Выбор языка программирования для старшеклассников

Currently, special attention is paid to the content of the training of schoolchildren in computer science. Interest in software development and code writing methods is growing every year. This is due to the change in methods and means of training in the field of writing program code associated with the emergence and development of new paradigms and programming languages. The purpose of the study is to substantiate the choice of a programming language for the preparation of high school students in the field of programming and solving the tasks of the Unified State Exam in computer science. Materials and methods of research: in the course of the research, a theoretical approach was used: the study, systematization and analysis of theoretical materials, scientific and methodological resources for teaching programming to schoolchildren, demos, test tasks, manuals, educational websites for preparing for the Unified State Exam in computer science, as well as many years of experience in teaching schoolchildren and students the basics of programming. Research results and their discussion: Programming languages PascalABC.NET and Python are currently the most popular in school education. The article analyzes the possibilities of these programming systems and the prospects of their application in teaching high school students the basics of programming. Examples of solving typical problems from the Unified State Exam in computer science in both languages are given to compare the speed and efficiency of the code. Conclusions. Language PascalABC.NET it has a number of advantages and can be recommended as a language for teaching programming. The language is high-performance, well structured, has strict typing and is adapted to the tasks of the Unified State Exam in computer science. When teaching future programmers, the basics of writing code, it is advisable to combine languages PascalABC.NET and Python.

APPLIED SOFTWARE FOR PERSONAL INFORMATION STORAGE

In today's world, the personal information of any person can be conventionally divided into two large categories: general and special. As you can understand from the name, the first category is responsible for the type of data that can be found in public access, namely: surname, first name, patronymic, signature, place and date of birth, citizenship, marital status, education, bank details, etc. Such a variety of personal data requires different methods and automated means of storage. Today, private and state institutions increasingly refuse to store information in paper form. This is explained by the low level of security of such storage facilities, which can be affected by fire, water, pests, etc. Information that exists in paper form is very easy to lose, for example, misplaced or lost during movement. It is shown that digital storage of information makes it possible to get rid of such problems. Personal data that is stored electronically can often be recovered even if the device from which it was accessed is lost. One of the main types of personal information in modern society is login data: login and password. That is why the algorithmic and software of the automated system for saving the user's personal data was developed. This system should enable the user to generate passwords resistant to standard hacking methods and store them in the database. The development of the automated system took place using the MVC architectural template, which is one of the options for implementing a multi-level architectural model. For detailed design and coding, an object-oriented Java programming language with static strict typing was chosen. It was also decided to develop an automated system in the form of a web application using the Spring framework. During the development process, a local database was designed, which will store personal data in the form of logins and passwords entered by the user or generated by the system itself. An algorithm for generating hack-resistant passwords has been developed. Hash algorithms are also used as an additional protection of the main password of the web application. A graphical interface has been created that allows the user to access the main functions of the automated system.

Исследование WebAssembly и сравнение производительности с JavaScript

Over the long history of the Internet, JavaScript has been the primary programming language in web development. Because of its simple syntax and support in all popular browsers, the language has gained popularity among the developers. However, as computer power and user demands evolved, simple sites turned into the web applications that are full-fledged analogues of the desktop applications. As capabilities grew, so did the performance requirements of such programs. Browser engines have developed ways to optimize the code they run, and intense competition between browsers has contributed to a qualitative increase in performance. Despite all the ways to increase the speed of execution of JavaScript code, the main stopping factor was the dynamic typing of the language. Because of dynamic typing, the browser engine needs to check each time the program is executed whether the variable is an integer, a float, or any other valid type. Thus, each JavaScript instruction has to go through several type checks and conversions, which slows down the execution. This led to the idea of using languages with strict typing, which could compensate for this drawback. But the browser engines cannot execute the code of other languages, that is why there appeared the technology WebAssembly. It allows writing code in languages with static typing, and then parses it into 
 a more native and machine-readable format, which speeds up execution of programs compared to JavaScript. The technology is cross-platform and supports the main programming languages: C++, C, Java, C#. WebAssembly is also implemented using JavaScript, which allows to use the concise JavaScript syntax and computing power of WebAssembly together.

The traditional core of DOM (Document Object Model) and its formal representation in fDOM

This article discusses the differences between two models of web documents: the traditional DOM (Document Object Model) and fDOM (formal DOM). The discussion begins with a description of Core DOM, which represents the structure of web documents as a hierarchical tree of nodes. Each node represents elements, attributes, and textual content, allowing for navigation, modification, and deletion of document components. The visual structure of DOM is illustrated using HTML code. The use of Isabelle/HOL, a higher-order logic system, for working with fDOM is then considered. This allows for the formalization of the mathematical properties of fDOM, ensuring their correctness and resistance to vulnerabilities. An example of code in Isabelle/HOL demonstrates how operations on web document elements can be defined and verified. The article also compares DOM and fDOM, highlighting differences in their approaches to representation and interaction with web documents. It is emphasized that while the traditional DOM provides a flexible interface for web documents, fDOM offers a more rigorous, mathematical representation, focused on precision and strictness. The discussion concludes with the advantages and disadvantages of fDOM. Among the advantages are formal verification, strong typing, consistent behavior, clear definitions, and enhanced security. However, increased complexity and development time, less flexibility, higher resource costs, and a steep learning curve are noted as disadvantages of fDOM. The conclusion emphasizes that fDOM offers a reliable, verified foundation for web applications but also introduces additional development requirements, making it particularly useful for applications where correctness and security are important.

Realizing FAIR Digital Objects for the German Helmholtz Association of Research Centres

Realizing FAIR Digital Objects for the German Helmholtz Association of Research Centres

CKRIPT: A NEW SCRIPTING LANGUAGE FOR WEB APPLICATIONS

The project aimed to develop and implement an efficient web server in the C++ programming language. A highly concurrent network server was achieved using system calls such as polls and a limited number of threads. The server has built-in support for a new scripting language called Ckript. It is an original project that exposes most of the server’s functionality and is the primary way of developing back-end web applications. Ckript is an interpreted language with a strong typing system, garbage collection, semi-manual memory management, first-class functions, explicit variable references, support for certain object-oriented patterns and many others. In the article the syntax of the language but also the environment architecture has been explained. Finally, the testing procedure has been described with the results’ presentation and discussion at each step.

Some Aspects of Strict Typing in TypeScript While Web Application Developing

The purpose of the article is to research, analyze and consider the general problems that TypeScript technology for strict typing solves when developing web applications. The research methodology consists of semantic analysis methods of the basic concepts of a given subject area (development of web applications using JavaScript and TypeScript). The article discusses the analysis results of the TypeScript technology’s use in comparison with JavaScript. The novelty of the research is the analysis of modern TypeScript technology and its solution to the problems of strict typing in the development of web applications. The conclusion of the research of the TypeScript technology carried out in the article is to determine its essence, the purpose of creation, advantages and disadvantages, and determine the situations of the appropriateness of its use.

Practical heuristics to improve precision for erroneous function argument swapping detection in C and C++

Argument selection defects, in which the programmer chooses the wrong argument to pass to a parameter from a potential set of arguments in a function call, is a widely investigated problem. The compiler can detect such misuse of arguments only through the argument and parameter type for statically typed programming languages. When adjacent parameters have the same type or can be converted between one another, a swapped or out of order call will not be diagnosed by compilers. Related research is usually confined to exact type equivalence, often ignoring potential implicit or explicit conversions. However, in current mainstream languages, like C++, built-in conversions between numerics and user-defined conversions may significantly increase the number of mistakes to go unnoticed. We investigated the situation for C and C++ languages where developers can define functions with multiple adjacent parameters that allow arguments to pass in the wrong order. When implicit conversions – such as parameter pairs of types ▪ – are taken into account, the number of mistake-prone functions markedly increases compared to only strict type equivalence. We analysed a sample of projects and categorised the offending parameter types. The empirical results should further encourage the language and library development community to emphasise the importance of strong typing and to restrict the proliferation of implicit conversions. However, the analysis produces a hard to consume amount of diagnostics for existing projects, and there are always cases that match the analysis rule but cannot be “fixed”. As such, further heuristics are needed to allow developers to refactor effectively based on the analysis results. We devised such heuristics, measured their expressive power, and found that several simple heuristics greatly help highlight the more problematic cases.

Cross-Platform Drilling 3D Visualization System Based on WebGL

This study develops a novel drilling 3D visualization solution based on WebGL, termed as WebDrillingViz, and introduces the system architecture design and software programming implementation. The software is part of the Engineering Technology Internet of Things (IoT) System, interfacing with other software, and also capable of direct hardware interfacing for data retrieval and system control. It is fully web-based, used real time, and used in RTOC (Real-Time Operating Center) of IoT system, which is a software system for drilling process remote monitor and decision. WebDrillingViz uses the most frontier HTML5 technology to realize a brand-new drilling 3D visualization system. The front end is designed in single-page application (SPA) mode and adopts technologies such as angular, bootstrap, and WebGL. The front-end uses single page application (SPA) mode, Angular, Bootstrap, WebGL and other technologies are used. The back-end data services provide data interface support for front-end visualization applications based on HTTP protocol which uses NodeJS, a lightweight development platform suitable for cloud platform, and Restify to realize a REST JSON API. Both sides are using the same object-oriented oriented development language—TypeScript. The front-end develops an easy-to-extend 3D visualization class library based on WebGL for drilling. It is encapsulated as Angular modularization to form an Angular component, which can be used standalone or integrated into other Angular applications. At the same time, the back-end microservice architecture combined with container and cloud technology is easy to maintain, deploy, and expand and has the advantages of being lightweight, cross-platform, flexible, and efficient. Using HTML5 standard and Bootstrap's responsive layout achieves cross-platform, which can support different operating systems and screen sizes. The system has better robustness and maintainability, thanks to the object-oriented and strong typing characteristics of TypeScript. Practical application shows that WebDrillingViz is efficient, capable of visualization of large drilling 3D scene, and compatible with mainstream devices, such as Windows, Linux, macOS, iOS, and Android. The use of open standards-based modern web technologies and data format enables a more lightweight and economical solution. WebGL, Angular, NodeJS, and TypeScript formed a powerful technology stack, which can be used as an excellent reference for other browser-based visualization development.

How can it be fixed in terms of typing

Motivation It is well known that C is a somewhat weakly typed (not strongly typed) language. However, it is not always clear how to let students (1) realize that this weak typing feature of C cou...

An Experiment with Denotational Semantics

The paper is devoted to showing how to systematically design a programming language in “reverse order”, i.e., from denotations to syntax. This construction is developed in an algebraic framework consisting of three many-sorted algebras: of denotations, of an abstract syntax and of a concrete syntax. These algebras are constructed in such a way that there is a unique homomorphism from concrete syntax to denotations, which constitutes the denotational semantics of the language. Besides its algebraic framework, the model is set-theoretic, i.e., the denotational domains are just sets, rather than Scott’s reflexive domains. The method is illustrated by a layer-by-layer development of a virtual language Lingua: an applicative layer, an imperative layer (with recursive procedures) and an SQL layer where Lingua is regarded as an API (Application Programming Interface) for an SQL engine. The latter is given a denotational semantics as well. Mathematically, the model is based on so-called naive denotational semantics (Blikle and Tarlecki in Information processing 83. Elsevier Science Publishers B.V., North-Holland, 1983), Many-sorted algebras (Goguen et al. in J ACM 24:68–95, 1977), equational grammars (Blikle in Inform Control 21:134–147, 1972), and a three-valued predicate calculus based on a three-valued proposition calculus of McCarthy (A basis for a mathematical theory of computation, North Holland, 1967). Three-valued predicates provide an adequate framework for error-handling mechanisms and also for the development of a Hoare-like logic with clean termination (Blikle in Acta Inform 16:199–217, 1981) for Lingua. That logic is used in Blikle and Chrząstowski-Wachtel (Complete Unambiguous, https://doi.org/10.13140/rg.2.2.27499.39201/3, 2019) for the development of correctness-preserving programs’ constructors. This issue is, however, not covered by the paper. The langue is equipped with a strong typing mechanism which covers basic types (numbers, Booleans, etc.), lists, arrays, record and their arbitrary combinations plus SQL-like types: rows, tables, and databases. The model of types includes SQL-integrity constraints.

Leveraging real-time and multitasking Ada capabilities to small microcontrollers

Small embedded microcontrollers typically operate for years without further programmer intervention, so that shipping software free of errors becomes paramount. The Ada programming language includes many safety characteristics (e.g., strong typing or contract-based programming) that help to largely reduce the number of errors introduced by programmers. However, Ada is barely used in microcontrollers with tight memory constraints due to the overhead introduced at run-time. The tasking semantics included in the language represent one major source of this overhead. In this paper we present a new Ada run-time environment that includes a new scheduling policy based on the one-shot task model that simplifies the implementation of the Ada tasking primitives and allows stack sharing techniques to be applied. Consequently, the proposed approach allows using the inherent safety characteristics of the Ada language along with a set of tasking constructs more suitable for small memory devices. Despite its simplicity, the tasking primitives have an equivalent, if not superior, expressiveness to the typical tasking constructs provided by the operating systems targeted to small microcontrollers. An implementation based on a small kernel, a modified run-time system and an automatic code transformation tool have been developed in the context of this work. Initial tests provide promising results, showing the tasking constructs are functionally correct and the proposed run-time features a small memory footprint.

The Typing System to Provide Compositional Thinking About Data Flows

The paper considers the approach to solving the problem of preventing the information system vulnerability that arises due to the insertion and / or performance of a semantically incorrect script (XSS-vulnerability). The solution of this task suggests modelling the information exchange between active objects. Modelling is supposed to be carried out within the framework of the basic applicative computing system, in which the code fragments can be modelled by applicative objects. An important part of the task is to check the correctness of the scenarios composition, which requires the tools make compositional thinking about data flows, both when they are processed by scripts and contain them. The correctness is proposed to be provided by supporting the fairly strong typing system that excludes incorrect combinations of scenarios. The type system is assumed to be immersed into the applicative environment. The system is proposed to be built on the basis of the homotopy type theory, which ensures, in particular, the introduction of independent and dependent types, as well as the definition of recursion and induction principles for them. Partial approbation of typing constructions is performed with the example of the problem of semantic support for the implementation of the best available technologies (BAT).

Low-Cost Dynamic Constraint Checking for the JVM

Abstract Using formal methods for software verification slowly becomes a standard in the industry. Overall it is a good idea to integrate as many checks as possible with the programming language. This is a major cause of the apparent success of strong typing in software, either performed on the compile time or dynamically, on runtime. Unfortunately, only some of the properties of software may be expressed in the type system of event the most sophisticated programming languages. Many of them must be performed dynamically. This paper presents a flexible library for the dynamically typed, functional programming language running in the JVM environment. This library offers its users a close to zero run-time overhead and strong mathematical background in category theory.

Proof checking and logic programming

Abstract In a world where trusting software systems is increasingly important, formal methods and formal proof can help provide some basis for trust. Proof checking can help to reduce the size of the trusted base since we do not need to trust an entire theorem prover: instead, we only need to trust a (smaller and simpler) proof checker. Many approaches to building proof checkers require embedding within them a full programming language. In most modern proof checkers and theorem provers, that programming language is a functional programming language, often a variant of ML. In fact, aspects of ML (e.g., strong typing, abstract datatypes, and higher-order programming) were designed to make ML a trustworthy “meta-language” for checking proofs. While there is considerable overlap between logic programming and proof checking (e.g., both benefit from unification, backtracking search, efficient term structures, etc.), the discipline of logic programming has, in fact, played a minor role in the history of proof checking. I will argue that logic programming can have a major role in the future of this important topic.

Transforming Dependency Structures to Logical Forms for Semantic Parsing

The strongly typed syntax of grammar formalisms such as CCG, TAG, LFG and HPSG offers a synchronous framework for deriving syntactic structures and semantic logical forms. In contrast—partly due to the lack of a strong type system—dependency structures are easy to annotate and have become a widely used form of syntactic analysis for many languages. However, the lack of a type system makes a formal mechanism for deriving logical forms from dependency structures challenging. We address this by introducing a robust system based on the lambda calculus for deriving neo-Davidsonian logical forms from dependency trees. These logical forms are then used for semantic parsing of natural language to Freebase. Experiments on the Free917 and Web-Questions datasets show that our representation is superior to the original dependency trees and that it outperforms a CCG-based representation on this task. Compared to prior work, we obtain the strongest result to date on Free917 and competitive results on WebQuestions.

Subscription Normalization for Effective Content-Based Messaging

Efficient subscription summarization and event matching is key to the scalability of content-based publish/subscribe networks (CPSNs). Current summarization and event matching mechanisms based on subscription subsumption induce heavy event processing load on brokers degrading the performance of CPSNs especially under high rates of churn, i.e., addition, deletion, or modification of subscriptions. Yet, many modern CPS applications such as location-based services or algorithmic trading inherently rely on high frequency subscription changes. This paper describes Beretta, a dynamic CPSN which sustains high throughput and low event-propagation latencies even under a high frequency of subscription changes. Beretta leverages strong event typing and represents all subscriptions in a normalized form as combinations of value intervals and set inclusions without compromising on expressiveness. Beretta’s “split and subsume” broker algorithm reduces the complexity of matching an event from $O(K\,N)$ to $O(K\,\log \,N + |result|)$ , with $N$ being the number of subscriptions for the event type and $K$ the number of its attributes. Event types and normalization are exploited to split subscriptions into predicates on individual event types and attributes and to efficiently regroup these in segment trees and hash maps which yield excellent subsumption properties and support attribute-wise split filtering during event matching. Normalization enables the systematic introduction of parameters into subscriptions to support both parametric and structural updates. This paper also empirically demonstrates the performance improvements due to our techniques through realistic algorithmic trading and highway traffic monitoring benchmarks.

XQuery and static typing: tackling the problem of backward axes

XQuery is a functional language dedicated to XML data querying and manipulation. As opposed to other W3C-standardized languages for XML (e.g. XSLT), it has been intended to feature strong static typing. Currently, however, some expressions of the language cannot be statically typed with any precision. We argue that this is due to a discrepancy between the semantics of the language and its type algebra: namely, the values of the language are (possibly inner) tree nodes, which may have siblings and ancestors in the data. The types on the other hand are regular tree types, as usual in the XML world: they describe sets of trees. The type associated to a node then corresponds to the subtree whose root is that node and contains no information about the rest of the data. This makes navigation expressions using `backward axes,' which return e.g. the siblings of a node, impossible to type. We discuss how to handle this discrepancy by improving the type system. We describe a logic-based language of extended types able to represent inner tree nodes and show how it can dramatically increase the precision of typing for navigation expressions. We describe how inclusion between these extended types and the classical regular tree types can be decided, allowing a hybrid system combining both type languages. The result is a net increase in precision of typing.