Programming Languages
Recently Published Documents





2021 ◽  
Vol 9 (19) ◽  
pp. 58-72
Leyanis Enoa Payés ◽  
Raydel Chávez Socarrás

Various processes are carried out in the Soil and Fertilizer Department of the Ministry of Agriculture at Granma's province in Cuba, including information management for investment approval. It becomes difficult due to the fact that it is carried out manually and through printed models, leading to insufficiencies in the personnel in charge of recording the information, difficulty in preserving relevant information and delay in the response process. In response to these needs, in this investigation, an informatics system is developed that will enrich the management of the information for the approval of investments of Soils and Fertilizers in Granma. For the development of the system was utilized as methodology of development of software Extreme Programming (XP). PHP 7.3.3 and SQL as server-side, client-side programming languages HTML 5, CSS 3, JavaScript and JQuery 1.2.2. APACHE 2.4.38 web application server, MySQL 5.0.12 as Database manager, CodeIgniter 3.1.10 as Framework and DBDesigner 4 as an aid to database modeling. As a result of investigation, a system validated by means of proofs of software was obtained, which vouch for his correct functioning.

Agliamutdinova D.B ◽  
Besshaposhnikov N.O. ◽  
Kushnirenko A.G. ◽  
Leonov A.G. ◽  
Raiko M.V.

Around the world, the “coding is the new literacy” thesis is beginning to be shared by an increasing number of decision-makers inside and outside national education systems. This leads to the inclusion of courses on information technology, including programming, in the curricula of school and early childhood education in various countries. In Russia, with its centralized education system, the amount of programming skills that a 9th grade graduate must master was established by the federal standard in mid-2021 and includes a certain set of initial programming skills that a student must be able to demonstrate by choosing one of the 6 full-text programming languages prescribed by the standard. Our experience shows that today the programming skills provided for by the specified standard can be successfully mastered by all primary school graduates (age 11-12), and we predict that the problem of early compulsory teaching in programming will be posed by Russian legislators and solved by the Russian education system in the near future. The main thesis of this article is that the best way to systematically teach the basics of programming to beginners of all ages, including elementary school students, is to consistently use the three approaches - icon-based, block-based, and text-based - provided that there is a methodological and technological continuity of software environments that support these three approaches. This continuity can be achieved by creating a consistent family of multiple learning environments. The article describes the experience of developing and using such a family of three software environments for the system of preschool and primary education in Russia, as well as for the system of teacher training in universities.

2021 ◽  
Siva Sankara Rao Kotha ◽  
Gopal T V

Abstract Over the years, the number of applications supporting enterprise business pro- cesses has increased. The challenge of integrating diverse systems is one of the many rea- sons why many organizations fail to achieve greater automation. To overcome this obstacle, they are turning to Enterprise Application Integration (EAI). Enterprise Application Integra- tion is a process that enables the integration of different applications. This allows the users to easily modify the functionality, share the information among the various applications and reusing the methods. The paper presents a formal method that includes the various levels of EAI. It highlights the various formal methods that can be used to achieve EAI’s seamless interoperation. It also supports the concurrent and dynamic system. This paper also proposes a new architecture for EAI that will help them achieve their goals. There are many formal methods for programming languages in software engineering, but most of them are not ad- equate for the development of complex systems. The author proposes a new methodology based on Petri net which is a graphical representation of semantics.

2022 ◽  
Vol 54 (8) ◽  
pp. 1-36
Maxime Lamothe ◽  
Yann-Gaël Guéhéneuc ◽  
Weiyi Shang

Recent software advances have led to an expansion of the development and usage of application programming interfaces (APIs). From millions of Android packages (APKs) available on Google Store to millions of open-source packages available in Maven, PyPI, and npm, APIs have become an integral part of software development. Like any software artifact, software APIs evolve and suffer from this evolution. Prior research has uncovered many challenges to the development, usage, and evolution of APIs. While some challenges have been studied and solved, many remain. These challenges are scattered in the literature, which hides advances and cloaks the remaining challenges. In this systematic literature review on APIs and API evolution, we uncover and describe publication trends and trending topics. We compile common research goals, evaluation methods, metrics, and subjects. We summarize the current state-of-the-art and outline known existing challenges as well as new challenges uncovered during this review. We conclude that the main remaining challenges related to APIs and API evolution are (1) automatically identifying and leveraging factors that drive API changes, (2) creating and using uniform benchmarks for research evaluation, and (3) understanding the impact of API evolution on API developers and users with respect to various programming languages.

2021 ◽  
Vol 5 (OOPSLA) ◽  
pp. 1-28
Eric Atkinson ◽  
Guillaume Baudart ◽  
Louis Mandel ◽  
Charles Yuan ◽  
Michael Carbin

Probabilistic programming languages aid developers performing Bayesian inference. These languages provide programming constructs and tools for probabilistic modeling and automated inference. Prior work introduced a probabilistic programming language, ProbZelus, to extend probabilistic programming functionality to unbounded streams of data. This work demonstrated that the delayed sampling inference algorithm could be extended to work in a streaming context. ProbZelus showed that while delayed sampling could be effectively deployed on some programs, depending on the probabilistic model under consideration, delayed sampling is not guaranteed to use a bounded amount of memory over the course of the execution of the program. In this paper, we the present conditions on a probabilistic program’s execution under which delayed sampling will execute in bounded memory. The two conditions are dataflow properties of the core operations of delayed sampling: the m -consumed property and the unseparated paths property . A program executes in bounded memory under delayed sampling if, and only if, it satisfies the m -consumed and unseparated paths properties. We propose a static analysis that abstracts over these properties to soundly ensure that any program that passes the analysis satisfies these properties, and thus executes in bounded memory under delayed sampling.

2021 ◽  
Vol 5 (OOPSLA) ◽  
pp. 1-28
Magnus Madsen ◽  
Jaco van de Pol

We present a simple, practical, and expressive relational nullable type system. A relational nullable type system captures whether an expression may evaluate to null based on its type, but also based on the type of other related expressions. The type system extends the Hindley-Milner type system with Boolean constraints, supports parametric polymorphism, and preserves principal types modulo Boolean equivalence. We show how to support full Hindley-Milner style type inference with an extension of Algorithm W. We conduct a preliminary study of open source projects showing that there is a need for relational nullable type systems across a wide range of programming languages. The most important findings from the study are: (i) programmers use programming patterns where the nullability of one expression depends on the nullability of other related expressions, (ii) such invariants are commonly enforced with run-time exceptions, and (iii) reasoning about these programming patterns requires not only knowledge of when an expression may evaluate to null, but also when it may evaluate to a non-null value. We incorporate these observations in the design of the proposed relational nullable type system.

2021 ◽  
Vol 5 (OOPSLA) ◽  
pp. 1-29
Weili Fu ◽  
Fabian Krause ◽  
Peter Thiemann

Dependently-typed programming languages are gaining importance, because they can guarantee a wide range of properties at compile time. Their use in practice is often hampered because programmers have to provide very precise types. Gradual typing is a means to vary the level of typing precision between program fragments and to transition smoothly towards more precisely typed programs. The combination of gradual typing and dependent types seems promising to promote the widespread use of dependent types. We investigate a gradual version of a minimalist value-dependent lambda calculus. Compile-time calculations and thus dependencies are restricted to labels, drawn from a generic enumeration type. The calculus supports the usual Pi and Sigma types as well as singleton types and subtyping. It is sufficiently powerful to provide flexible encodings of variant and record types with first-class labels. We provide type checking algorithms for the underlying label-dependent lambda calculus and its gradual extension. The gradual type checker drives the translation into a cast calculus, which extends the original language. The cast calculus comes with several innovations: refined typing for casts in the presence of singletons, type reduction in casts, and fully dependent Sigma types. Besides standard metatheoretical results, we establish the gradual guarantee for the gradual language.

2021 ◽  
Vol 5 (OOPSLA) ◽  
pp. 1-30
Stefanos Chaliasos ◽  
Thodoris Sotiropoulos ◽  
Georgios-Petros Drosos ◽  
Charalambos Mitropoulos ◽  
Dimitris Mitropoulos ◽  

Despite the substantial progress in compiler testing, research endeavors have mainly focused on detecting compiler crashes and subtle miscompilations caused by bugs in the implementation of compiler optimizations. Surprisingly, this growing body of work neglects other compiler components, most notably the front-end. In statically-typed programming languages with rich and expressive type systems and modern features, such as type inference or a mix of object-oriented with functional programming features, the process of static typing in compiler front-ends is complicated by a high-density of bugs. Such bugs can lead to the acceptance of incorrect programs (breaking code portability or the type system's soundness), the rejection of correct (e.g. well-typed) programs, and the reporting of misleading errors and warnings. We conduct, what is to the best of our knowledge, the first empirical study for understanding and characterizing typing-related compiler bugs. To do so, we manually study 320 typing-related bugs (along with their fixes and test cases) that are randomly sampled from four mainstream JVM languages, namely Java, Scala, Kotlin, and Groovy. We evaluate each bug in terms of several aspects, including their symptom, root cause, bug fix's size, and the characteristics of the bug-revealing test cases. Some representative observations indicate that: (1) more than half of the typing-related bugs manifest as unexpected compile-time errors: the buggy compiler wrongly rejects semantically correct programs, (2) the majority of typing-related bugs lie in the implementations of the underlying type systems and in other core components related to operations on types, (3) parametric polymorphism is the most pervasive feature in the corresponding test cases, (4) one third of typing-related bugs are triggered by non-compilable programs. We believe that our study opens up a new research direction by driving future researchers to build appropriate methods and techniques for a more holistic testing of compilers.

2021 ◽  
Vol 5 (OOPSLA) ◽  
pp. 1-26
Guoqiang Zhang ◽  
Yuanchao Xu ◽  
Xipeng Shen ◽  
Işıl Dillig

Many data processing systems allow SQL queries that call user-defined functions (UDFs) written in conventional programming languages. While such SQL extensions provide convenience and flexibility to users, queries involving UDFs are not as efficient as their pure SQL counterparts that invoke SQL’s highly-optimized built-in functions. Motivated by this problem, we propose a new technique for translating SQL queries with UDFs to pure SQL expressions. Unlike prior work in this space, our method is not based on syntactic rewrite rules and can handle a much more general class of UDFs. At a high-level, our method is based on counterexample-guided inductive synthesis (CEGIS) but employs a novel compositional strategy that decomposes the synthesis task into simpler sub-problems. However, because there is no universal decomposition strategy that works for all UDFs, we propose a novel lazy inductive synthesis approach that generates a sequence of decompositions that correspond to increasingly harder inductive synthesis problems. Because most realistic UDF-to-SQL translation tasks are amenable to a fine-grained decomposition strategy, our lazy inductive synthesis method scales significantly better than traditional CEGIS. We have implemented our proposed technique in a tool called CLIS for optimizing Spark SQL programs containing Scala UDFs. To evaluate CLIS, we manually study 100 randomly selected UDFs and find that 63 of them can be expressed in pure SQL. Our evaluation on these 63 UDFs shows that CLIS can automatically synthesize equivalent SQL expressions in 92% of the cases and that it can solve 2.4× more benchmarks compared to a baseline that does not use our compositional approach. We also show that CLIS yields an average speed-up of 3.5× for individual UDFs and 1.3× to 3.1× in terms of end-to-end application performance.

Sign in / Sign up

Export Citation Format

Share Document