Articoli di riviste sul tema "Language Compiler languages PL"
Segui questo link per vedere altri tipi di pubblicazioni sul tema: Language Compiler languages PL.
Cita una fonte nei formati APA, MLA, Chicago, Harvard e in molti altri stili
Vedi i top-50 articoli di riviste per l'attività di ricerca sul tema "Language Compiler languages PL".
Accanto a ogni fonte nell'elenco di riferimenti c'è un pulsante "Aggiungi alla bibliografia". Premilo e genereremo automaticamente la citazione bibliografica dell'opera scelta nello stile citazionale di cui hai bisogno: APA, MLA, Harvard, Chicago, Vancouver ecc.
Puoi anche scaricare il testo completo della pubblicazione scientifica nel formato .pdf e leggere online l'abstract (il sommario) dell'opera se è presente nei metadati.
Vedi gli articoli di riviste di molte aree scientifiche e compila una bibliografia corretta.
1
Bodik, Rastislav. "Small languages in an undergraduate PL/Compiler course". ACM SIGPLAN Notices 43, n. 11 (30 novembre 2008): 39–44. http://dx.doi.org/10.1145/1480828.1480836.
Testo completo
2
Dzhidzhoyev, Vladislav Muratovich, Ruben Arturovich Buchatskiy, Michael Vyacheslavovich Pantilimonov e Alexander Nikolaevich Tomilin. "Dynamic Compilation of User-Defined Functions in PL/pgSQL Language". Proceedings of the Institute for System Programming of the RAS 32, n. 5 (2020): 67–80. http://dx.doi.org/10.15514/ispras-2020-32(5)-5.
Testo completoAbstract (sommario):
Many modern RDBMS provide procedural extensions for SQL programming language, which allow users to perform server-side complex computations. Use of such extensions improves modularity and code reuse, simplifies programming of application logic, and helps developers to avoid network overhead and enhance performance. Interpretation is mostly used to execute SQL queries and procedural extensions code, resulting in significant computational overhead because of indirect function calls and performing of generic checks. Moreover, most RDBMS use different engines for SQL queries execution and procedural extensions code execution, and it is necessary to perform additional computations to switch between different engines. Thus, interpretation of SQL queries combined with interpretation of procedural extensions code may drastically degrade performance of RDBMS. One solution is to use a dynamic compilation technique. In this paper, we describe the technique of dynamic compilation of PL/pgSQL procedural language for the PostgreSQL database system using LLVM compiler infrastructure. Dynamic compiler of PL/pgSQL procedural language is developed as part of PostgreSQL queries dynamic compiler. Proposed technique helps to get rid of computational overhead caused by interpretation usage. Synthetic performance tests show that the developed solution speeds up SQL queries execution by several times.
3
Jain, Abhishek, Manohar Kumar e Manohar Kumar. "System Programming Drawbacks". Journal of Advance Research in Computer Science & Engineering (ISSN: 2456-3552) 2, n. 4 (30 aprile 2015): 16–22. http://dx.doi.org/10.53555/nncse.v2i4.453.
Testo completoAbstract (sommario):
A system programming language usually refers to a programming language used for system programming; such languages are designed for writing system software, which usually requires different development approaches when compared to application software. System software is computer software designed to operate and control the computer hardware, and to provide a platform for running application software. System software includes software categories such as operating systems, utility software, device drivers, compilers, and linkers. In contrast with application languages, system programming languages typically offer more-direct access to the physical hardware of the machine: an archetypical system programming language in this sense was BCPL. System programming languages often lack built in input/output facilities because a system-software project usually develops its own input/output or builds on basic monitor I/O or screen management services facilities. The distinction between languages for system programming and applications programming became blurred with widespread popularity of PL/I, C and Pascal.
4
Navas-López, Eduardo Adam. "Modular and Didactic Compiler Design with Xml Inter-Phases Communication". International Journal of Computer Science, Engineering and Information Technology 12, n. 1 (28 febbraio 2022): 1–20. http://dx.doi.org/10.5121/ijcseit.2022.12101.
Testo completoAbstract (sommario):
In Compiler Design courses, students learn how a program written in high level programming language and designed for humans understanding is systematically converted into low level assembly language understood by machines, through different representations. This article presents the design, educative characteristics and possibilities of a modular and didactic compiler for a Pascal-like programming minilanguage that is super-set of Niklaus Wirth's PL/0. The main feature is that it implements the compiling phases in such a way that the information delivered to each next one may be reflected as an XML document, which can be studied separately. It is also shown that its design is suitable for being included as learning tool into compiler design courses. It is possible to implement a compiler in a high-level language like Python.
5
Justo, David, Shaoqing Yi, Lukas Stadler, Nadia Polikarpova e Arun Kumar. "Towards a polyglot framework for factorized ML". Proceedings of the VLDB Endowment 14, n. 12 (luglio 2021): 2918–31. http://dx.doi.org/10.14778/3476311.3476372.
Testo completoAbstract (sommario):
Optimizing machine learning (ML) workloads on structured data is a key concern for data platforms. One class of optimizations called "factorized ML" helps reduce ML runtimes over multi-table datasets by pushing ML computations down through joins, avoiding the need to materialize such joins. The recent Morpheus system automated factorized ML to any ML algorithm expressible in linear algebra (LA). But all such prior factorized ML/LA stacks are restricted by their chosen programming language (PL) and runtime environment, limiting their reach in emerging industrial data science environments with many PLs (R, Python, etc.) and even cross-PL analytics workflows. Re-implementing Morpheus from scratch in each PL/environment is a massive developability overhead for implementation, testing, and maintenance. We tackle this challenge by proposing a new system architecture, Trinity , to enable factorized LA logic to be written only once and easily reused across many PLs/LA tools in one go . To do this in an extensible and efficient manner without costly data copies, Trinity leverages and extends an emerging industrial polyglot compiler and runtime, Oracle's GraalVM. Trinity enables factorized LA in multiple PLs and even cross-PL workflows. Experiments with real datasets show that Trinity is significantly faster than materialized execution (> 8x speedups in some cases), while being largely competitive to a prior single PL-focused Morpheus stack.
6
Dhak, Bharat, Prachi Goje, Abhishek Raut, Ashwini Rane e Avantika Tamsetwar. "Online Compiler with Whiteboard". International Journal for Research in Applied Science and Engineering Technology 11, n. 4 (30 aprile 2023): 2023–27. http://dx.doi.org/10.22214/ijraset.2023.50509.
Testo completoAbstract (sommario):
Abstract: The Internet has proved to be a life-changing invention of our time. Not only it is itself an invention, but it has been the key player to major things that have been invented in the twentieth century. The internet has proven itself in re-inventing almost everything, with education being no exception to it. CodeBox is also an effort, via the internet, to educate the young minds on the how-tos of coding and developing the spirit of competitive coding. It takes a lot of time and practice to get good at coding, and CodeBox aims to assist the user in this journey. In other code editors they offer facility to run languages which includes HTML, CSS, JAVASCRIPT. This Languages are web based totally languages the ones code editors are permit to run the programming languages that’s why programmers face many difficulties to run programming languages which include JAVA, php and many others. but in our venture, we add programming language which is java .by way of the usage of serverprimarily based code editor programmer can run programming language i.e., JAVA. The project: "Quiz utility" is a set of quantity of different forms of quizzes like technical, video games, sports, etc. A person can access/play all the quiz and may try any of the only. There could be restrained number of questions and for every correct solution person will get a credit score
7
Wermuth, Maria-Cornelia. "Language localization in scientific drug information". Journal of Internationalization and Localization 3, n. 1 (11 agosto 2016): 74–94. http://dx.doi.org/10.1075/jial.3.1.05wer.
Testo completoAbstract (sommario):
Although localization is, in the first place, related to the cultural adaptation and translation of software and websites, it is important for written materials as well. In this paper we investigate how specialized medical discourse used in the Summary of Product Characteristics (SmPC) is localized in patient leaflets (PL). Both documents are issued by the European Medicines Agency (EMA) and provide detailed information on the product compiled and distributed by the drug manufacturer, after EMA review and approval. We describe by means of a case study the formal and linguistic features of SmPCs and PLs and we investigate how the specialized source text is localized in its patient-friendly version. The aim of this investigation is to increase awareness and understanding of localization strategies adopted on the intralingual level in the communication of scientific-medical knowledge to a non-expert audience.
8
Gagan, B. R., Shivaprakash T, Thirumalai Shaktivel C, Vaishak P e Kushal Kumar B. N. "Design of a New Language Seeks Literature Survey". International Journal for Research in Applied Science and Engineering Technology 10, n. 3 (31 marzo 2022): 1623–27. http://dx.doi.org/10.22214/ijraset.2022.40949.
Testo completoAbstract (sommario):
Abstract: In a scientific study, computing is a must-have tool. In general, scientists have various difficulties, requirements, and views when it comes to computation, which need to be addressed by the programming language that they use, this cannot be satisfied by general-purpose languages. Also, researchers need to concentrate on the issue they are working on rather than the optimizations for the calculations, so instead of using a general-purpose language, if there exists a language whose compiler would take care of those optimizations, it would make their work easier and faster. This is a survey of the work undertaken to design the programming language and its compiler. The primary goal of this research is to examine the function of work, implementation strategy, steps taken for improving the performance, the procedure of benchmarking, and finally, the outcome of the papers studied. The survey's main conclusions are that: the most common language mentioned among the papers was Python which appears to be more popular among developers due to its simple syntax and library support for computing. On the other hand, Python lacks performance, to compensate for this performance issue, the community has developed tools like Cython, Numba, Pythran, etc, which can be used to speed up Python. Domain-specific languages such as Wolfram, Seq, and ELI highlighted various methods for overcoming problems. Some languages like Wolfram and ELI moved from interpreter to compiler to get the performance boost. Most of the compilers use LLVM as the backend for optimizations and code generation. Keywords: scientific computation, compiler, programming language
9
Chen, Zhe, Yunlong Zhu e Zhemin Wang. "Design and Implementation of an Aspect-Oriented C Programming Language". Proceedings of the ACM on Programming Languages 8, OOPSLA1 (29 aprile 2024): 642–69. http://dx.doi.org/10.1145/3649834.
Testo completoAbstract (sommario):
Aspect-Oriented Programming (AOP) is a programming paradigm that implements crosscutting concerns in a modular way. People have witnessed the prosperity of AOP languages for Java and C++, such as AspectJ and AspectC++, which has propelled AOP to become an important programming paradigm with many interesting application scenarios, e.g., runtime verification. In contrast, the AOP languages for C are still poor and lack compiler support. In this paper, we design a new general-purpose and expressive aspect-oriented C programming language, namely Aclang, and implement a compiler for it, which brings fully-fledged AOP support into the C domain. We have evaluated the effectiveness and performance of our compiler against two state-of-the-art tools, ACC and AspectC++. In terms of effectiveness, Aclang outperforms ACC and AspectC++. In terms of performance, Aclang outperforms ACC in execution time and outperforms AspectC++ in both execution time and memory consumption.
10
Paraskevopoulou, Zoe, John M. Li e Andrew W. Appel. "Compositional optimizations for CertiCoq". Proceedings of the ACM on Programming Languages 5, ICFP (22 agosto 2021): 1–30. http://dx.doi.org/10.1145/3473591.
Testo completoAbstract (sommario):
Compositional compiler verification is a difficult problem that focuses on separate compilation of program components with possibly different verified compilers. Logical relations are widely used in proving correctness of program transformations in higher-order languages; however, they do not scale to compositional verification of multi-pass compilers due to their lack of transitivity. The only known technique to apply to compositional verification of multi-pass compilers for higher-order languages is parametric inter-language simulations (PILS), which is however significantly more complicated than traditional proof techniques for compiler correctness. In this paper, we present a novel verification framework for lightweight compositional compiler correctness . We demonstrate that by imposing the additional restriction that program components are compiled by pipelines that go through the same sequence of intermediate representations , logical relation proofs can be transitively composed in order to derive an end-to-end compositional specification for multi-pass compiler pipelines. Unlike traditional logical-relation frameworks, our framework supports divergence preservation—even when transformations reduce the number of program steps. We achieve this by parameterizing our logical relations with a pair of relational invariants . We apply this technique to verify a multi-pass, optimizing middle-end pipeline for CertiCoq, a compiler from Gallina (Coq’s specification language) to C. The pipeline optimizes and closure-converts an untyped functional intermediate language (ANF or CPS) to a subset of that language without nested functions, which can be easily code-generated to low-level languages. Notably, our pipeline performs more complex closure-allocation optimizations than the state of the art in verified compilation. Using our novel verification framework, we prove an end-to-end theorem for our pipeline that covers both termination and divergence and applies to whole-program and separate compilation, even when different modules are compiled with different optimizations. Our results are mechanized in the Coq proof assistant.
11
Xu, Haoran, e Fredrik Kjolstad. "Copy-and-patch compilation: a fast compilation algorithm for high-level languages and bytecode". Proceedings of the ACM on Programming Languages 5, OOPSLA (20 ottobre 2021): 1–30. http://dx.doi.org/10.1145/3485513.
Testo completoAbstract (sommario):
Fast compilation is important when compilation occurs at runtime, such as query compilers in modern database systems and WebAssembly virtual machines in modern browsers. We present copy-and-patch, an extremely fast compilation technique that also produces good quality code. It is capable of lowering both high-level languages and low-level bytecode programs to binary code, by stitching together code from a large library of binary implementation variants. We call these binary implementations stencils because they have holes where missing values must be inserted during code generation. We show how to construct a stencil library and describe the copy-and-patch algorithm that generates optimized binary code. We demonstrate two use cases of copy-and-patch: a compiler for a high-level C-like language intended for metaprogramming and a compiler for WebAssembly. Our high-level language compiler has negligible compilation cost: it produces code from an AST in less time than it takes to construct the AST. We have implemented an SQL database query compiler on top of this metaprogramming system and show that on TPC-H database benchmarks, copy-and-patch generates code two orders of magnitude faster than LLVM -O0 and three orders of magnitude faster than higher optimization levels. The generated code runs an order of magnitude faster than interpretation and 14% faster than LLVM -O0. Our WebAssembly compiler generates code 4.9X-6.5X faster than Liftoff, the WebAssembly baseline compiler in Google Chrome. The generated code also outperforms Liftoff's by 39%-63% on the Coremark and PolyBenchC WebAssembly benchmarks.
12
Addis, Andrea, e Olimpia Giuliana Loddo. "An Intersemiotic Translation of Normative Utterances to Machine Language". International journal of Web & Semantic Technology 13, n. 1 (31 gennaio 2022): 1–11. http://dx.doi.org/10.5121/ijwest.2022.13101.
Testo completoAbstract (sommario):
Programming Languages (PL) effectively performs an intersemiotic translation from a natural language to machine language. PL comprises a set of instructions to implement algorithms, i.e., to perform (computational) tasks. Similarly to Normative Languages (NoL), PLs are formal languages that can perform both regulative and constitutive functions. The paper presents the first results of interdisciplinary research aimed at highlighting the similarities between NoL (social sciences) and PL (computer science) through everyday life examples, exploiting Object-Oriented Programming Language tools and an Internet of Things (IoT) system as a case study. Given the pandemic emergency, the urge to move part of our social life to the digital world arose, together with the need to effectively transpose regulative rules and constitutive rules through different strategies for translating a normative utterance expressed in natural language.
13
Tassarotti, Joseph, e Jean-Baptiste Tristan. "Verified Density Compilation for a Probabilistic Programming Language". Proceedings of the ACM on Programming Languages 7, PLDI (6 giugno 2023): 615–37. http://dx.doi.org/10.1145/3591245.
Testo completoAbstract (sommario):
This paper presents ProbCompCert, a compiler for a subset of the Stan probabilistic programming language (PPL), in which several key compiler passes have been formally verified using the Coq proof assistant. Because of the probabilistic nature of PPLs, bugs in their compilers can be difficult to detect and fix, making verification an interesting possibility. However, proving correctness of PPL compilation requires new techniques because certain transformations performed by compilers for PPLs are quite different from other kinds of languages. This paper describes techniques for verifying such transformations and their application in ProbCompCert. In the course of verifying ProbCompCert, we found an error in the Stan language reference manual related to the semantics and implementation of a key language construct.
14
Cristiá, Maximiliano, Diego A. Hollmann e Claudia Frydman. "A multi-target compiler for CML-DEVS". SIMULATION 95, n. 1 (13 aprile 2018): 11–29. http://dx.doi.org/10.1177/0037549718765080.
Testo completoAbstract (sommario):
Discrete Event System Specification (DEVS) is a modular and hierarchical formalism for system modeling and simulation. DEVS models can be mathematically described; simulation is performed by tools called concrete simulators. Concerning atomic DEVS models, each concrete simulator has its own input language which is, essentially, a general-purpose programming language (such as Java or C++). Hence, once engineers have written the mathematical model, they need to manually translate it into the input language of the concrete simulator of their choice. In this paper we present a multi-target compiler for atomic DEVS models written in CML-DEVS, a mathematics-based DEVS modeling language. This multi-target compiler is able to compile a CML-DEVS model to the input languages of the PowerDEVS and DEVS-Suite concrete simulators. In this way, the CML-DEVS compiler frees engineers from the manual translation of their mathematical models. In fact, the same mathematical model can be simulated on both simulators by simply recompiling the model. The CML-DEVS multi-target compiler can be easily extended to produce code for other concrete simulators.
15
Livinskii, Vsevolod, Dmitry Babokin e John Regehr. "Fuzzing Loop Optimizations in Compilers for C++ and Data-Parallel Languages". Proceedings of the ACM on Programming Languages 7, PLDI (6 giugno 2023): 1826–47. http://dx.doi.org/10.1145/3591295.
Testo completoAbstract (sommario):
Compilers are part of the foundation upon which software systems are built; they need to be as correct as possible. This paper is about stress-testing loop optimizers; it presents a major reimplementation of Yet Another Random Program Generator (YARPGen), an open-source generative compiler fuzzer. This new version has found 122 bugs, both in compilers for data-parallel languages, such as the Intel® Implicit SPMD Program Compiler and the Intel® oneAPI DPC++ compiler, and in C++ compilers such as GCC and Clang/LLVM. The first main contribution of our work is a novel method for statically avoiding undefined behavior when generating loops; the resulting programs conform to the relevant language standard, enabling automated testing. The second main contribution is a collection of mechanisms for increasing the diversity of generated loop code; in our evaluation, we demonstrate that these make it possible to trigger loop optimizations significantly more often, providing opportunities to discover bugs in the optimizers.
16
Ferreira, Elisabete, Rogério Paulo, Cruz da e Pedro Henriques. "Integration of the ST language in a model-based engineering environment for control systems: An approach for compiler implementation". Computer Science and Information Systems 5, n. 2 (2008): 87–101. http://dx.doi.org/10.2298/csis0802087f.
Testo completoAbstract (sommario):
In the context of the INTEGRA project, compilation and code generation features for behavior definition are to be integrated in an existing model-based engineering environment for control systems. The devised compiler architecture is domain-specific and provides support for multiple input languages and multiple target platforms. In this paper we discuss an architectural approach in which the compiling process is organized in two different stages: the compiling stage and the linking stage. The compiling stage generates target independent code from possibly multiple input languages. The linking stage assembles precompiled code modules and generates a target specific executable code for a given virtual machine. To be more specific this paper describes the integration of the ST language in the tool core meta-model and the ST compiler is presented as an application case study. .
17
Sun, Bojin, e Minze Sun. "Concurrency and Operating Systems, Processors, and Programming Languages". Highlights in Science, Engineering and Technology 39 (1 aprile 2023): 881–87. http://dx.doi.org/10.54097/hset.v39i.6667.
Testo completoAbstract (sommario):
The main content of our research is to optimize and improve the concurrency of the system from the three aspects of operating system, processor and programming language. Previous solutions have focused on hardware techniques to improve concurrency. Our goal is to solve the problem of resource occupancy and contention through algorithms, data structures, optimization interrupts, and optimization of process and coroutine scheduling. In the final ideal case, the finite-state machine switching code generated by the compiler can be used to switch the coroutines in the same process. For threads, the thread code provided by the kernel does the switching. The asynchronous system call is optimized to automatically generate the corresponding system call request code according to the execution compiler and maintain the coroutine control block data structure. This is also the most difficult part of this research.
18
Leskelä, Leealaura, Arto Mustajoki e Aino Piehl. "Easy and plain languages as special cases of linguistic tailoring and standard language varieties". Nordic Journal of Linguistics 45, n. 2 (ottobre 2022): 194–213. http://dx.doi.org/10.1017/s0332586522000142.
Testo completoAbstract (sommario):
AbstractThis article aims to introduce new insights to further the understanding of easy language (EL) and plain language (PL) as examples of tailored language and place them within a broader context of linguistic varieties. We examine EL and PL in relation to standard language, and we consider the degree of conscious effort required in tailoring and the compliance with the codified norms of standard language. Both EL and PL are used in asymmetric communication: PL to mediate between specialists and the general public and EL in communication with people with language barriers. We argue that while these varieties have similar purposes and methods, they also have significant differences; for example, the tailoring moves in opposite directions, as PL seeks general comprehensibility and EL aims to reach special and vulnerable groups. The differences between PL and EL are primarily linked to social prestige and the potential risk of stigma related to their use.
19
Vidhan Singh, Dayanand Choudhary, Nagendra Singh, Manish Kumar,. "Introduction to the basic data types in programming". Tuijin Jishu/Journal of Propulsion Technology 43, n. 4 (26 novembre 2023): 246–49. http://dx.doi.org/10.52783/tjjpt.v43.i4.2345.
Testo completoAbstract (sommario):
In the era of technology, the need for developing a language to communicate with computers led to the development of different programming languages. Computers cannot understand the commands in the normal human languages so we needed programming languages to communicate with computers and develop different apps, website and software programs. A crucial part for programming languages are data types. Data types are the classifications of data which tells the compiler or interpreter how the developer wants to insert the data.
20
Artal, Cayetano Guerra, Maria Dolores Afonso Suarez, Idafen Santana Perez e Ruben Quesada Lopez. "OLC, On-Line Compiler to Teach Programming Languages". International Journal of Computers Communications & Control 3, n. 1 (1 marzo 2008): 69. http://dx.doi.org/10.15837/ijccc.2008.1.2376.
Testo completoAbstract (sommario):
The advance of Internet towards Web 2.0 conveys the potential it has in a wide range of scopes. The ongoing progress of the Web technology and its availability in teaching and learning, as well as a students’ profile increasingly more used to managing an important amount of digital information, offers lecturers the opportunity and challenge of putting at students’ disposal didactic tools making use of the Internet. Programming is one of the essential areas taught in university studies of Computer Science and other engineering degrees. At present, it is a knowledge acquired through tutorial classes and the practice with different tools for programming. This paper shows the acquired experience in the development and use of a simple compiler accessible through a Web page. In addition it presents a teaching proposal for its use in subjects that include programming languages lessons. OLC - On-Line Compiler - is an application which greatly lightens the student’s workload at the initial stage of programming. During this initial period they will neither have to deal with the complexities of the installation and the configuration of these types of tools, nor with the understanding of multiple options which they present. Therefore students can concentrate on the comprehension of the programming structures and the programming language to be studied.
21
BERNARD, THOMAS A. M., CLEMENS GRELCK e CHRIS R. JESSHOPE. "ON THE COMPILATION OF A LANGUAGE FOR GENERAL CONCURRENT TARGET ARCHITECTURES". Parallel Processing Letters 20, n. 01 (marzo 2010): 51–69. http://dx.doi.org/10.1142/s0129626410000053.
Testo completoAbstract (sommario):
The challenge of programming many-core architectures efficiently and effectively requires models and methods to co-design chip architectures and their software tool chain, using an approach that is both vertical and general. In this paper, we present compilation schemes for a general model of concurrency captured in a parallel language designed for system-level programming and as a target for higher level compilers. We also expose the challenges of integrating these transformation rules into a sequential-oriented compiler. Moreover, we discuss resource mapping inherent to those challenges. Our aim has been to reuse as much of the existing sequential compiler technology as possible in order to harness decades of prior research in compiling sequential languages.
22
Dold, Axel, Friedrich von Henke e Wolfgang Goerigk. "A Completely Verified Realistic Bootstrap Compiler". International Journal of Foundations of Computer Science 14, n. 04 (agosto 2003): 659–80. http://dx.doi.org/10.1142/s0129054103001947.
Testo completoAbstract (sommario):
This paper reports on a large verification effort in constructing an initial fully trusted bootstrap compiler executable for a realistic system programming language and real target processor. The construction and verification process comprises three tasks: the verification of the compiling specification (a relation between abstract source and target programs) with respect to the language semantics and a realistic correctness criterion. This proof has been completely mechanized using the PVS verification system and is one of the largest case-studies in formal verification we are aware of. Second, the implementation of the specification in the high-level source language following a transformational approach, and finally, the implementation and verification of a binary executable written in the compiler's target language. For the latter task, a realistic technique has been developed, which is based on rigorous a-posteriori syntactic code inspection and which guarantees, for the first time, trusted execution of generated machine programs. The context of this work is the joint German research effort Verifix aiming at developing methods for the construction of correct compilers for realistic source languages and real target processors.
23
Singh, Rashandeep, e Dr Gulshan Goyal. "Algorithm Design for Deterministic Finite Automata for a Given Regular Language with Prefix Strings". Journal of Scientific Research 66, n. 02 (2022): 16–21. http://dx.doi.org/10.37398/jsr.2022.660203.
Testo completoAbstract (sommario):
Computer Science and Engineering have given us the field of automata theory, one of the largest areas that is concerned with the efficiency of an algorithm in solving a problem on a computational model. Various classes of formal languages are represented using Chomsky hierarchy. These languages are described as a set of specific strings over a given alphabet and can be described using state or transition diagrams. The state/transition diagram for regular languages is called a finite automaton which is used in compiler design for recognition of tokens. Other applications of finite automata include pattern matching, speech and text processing, CPU machine operations, etc. The construction of finite automata is a complicated and challenging process as there is no fixed mathematical approach that exists for designing Deterministic Finite Automata (DFA) and handling the validations for acceptance or rejection of strings. Consequently, it is difficult to represent the DFA’s transition table and graph. Novel learners in the field of theoretical computer science often feel difficulty in designing of DFA The present paper proposes an algorithm for designing of deterministic finite automata (DFA) for a regular language with a given prefix. The proposed method further aims to simplify the lexical analysis process of compiler design.
24
SWAMY, NIKHIL, JUAN CHEN, CÉDRIC FOURNET, PIERRE-YVES STRUB, KARTHIKEYAN BHARGAVAN e JEAN YANG. "Secure distributed programming with value-dependent types". Journal of Functional Programming 23, n. 4 (luglio 2013): 402–51. http://dx.doi.org/10.1017/s0956796813000142.
Testo completoAbstract (sommario):
AbstractDistributed applications are difficult to program reliably and securely. Dependently typed functional languages promise to prevent broad classes of errors and vulnerabilities, and to enable program verification to proceed side-by-side with development. However, as recursion, effects, and rich libraries are added, using types to reason about programs, specifications, and proofs becomes challenging. We present F*, a full-fledged design and implementation of a new dependently typed language for secure distributed programming. Our language provides arbitrary recursion while maintaining a logically consistent core; it enables modular reasoning about state and other effects using affine types; and it supports proofs of refinement properties using a mixture of cryptographic evidence and logical proof terms. The key mechanism is a new kind system that tracks several sub-languages within F* and controls their interaction. F* subsumes two previous languages, F7 and Fine. We prove type soundness (with proofs mechanized in Coq) and logical consistency for F*. We have implemented a compiler that translates F* to .NET bytecode, based on a prototype for Fine. F* provides access to libraries for concurrency, networking, cryptography, and interoperability with C#, F#, and the other .NET languages. The compiler produces verifiable binaries with 60% code size overhead for proofs and types, as much as a 45x improvement over the Fine compiler, while still enabling efficient bytecode verification. We have programmed and verified nearly 50,000 lines of F* including new schemes for multi-party sessions; a zero-knowledge privacy-preserving payment protocol; a provenance-aware curated database; a suite of web-browser extensions verified for authorization properties; a cloud-hosted multi-tier web application with a verified reference monitor; the core F* typechecker itself; and programs translated to F* from other languages such as F7 and JavaScript.
25
Lai, Yong, Dayou Liu e Minghao Yin. "New Canonical Representations by Augmenting OBDDs with Conjunctive Decomposition". Journal of Artificial Intelligence Research 58 (8 marzo 2017): 453–521. http://dx.doi.org/10.1613/jair.5271.
Testo completoAbstract (sommario):
We identify two families of canonical knowledge compilation languages. Both families augment ROBDD with conjunctive decomposition bounded by an integer i ranging from 0 to ∞. In the former, the decomposition is finest and the decision respects a chain C of variables, while both the decomposition and decision of the latter respect a tree T of variables. In particular, these two families cover the three existing languages ROBDD, ROBDD with as many implied literals as possible, and AND/OR BDD. We demonstrate that each language in the first family is complete, while each one in the second family is incomplete with expressivity that does not decrease with incremental i. We also demonstrate that the succinctness does not decrease from the i-th language in the second family to the i-th language in the first family, and then to the (i+1)-th language in the first family. For the operating efficiency, on the one hand, we show that the two families of languages support a rich class of tractable logical operations, and particularly the tractability of each language in the second family is not less than that of ROBDD; and on the other hand, we introduce a new time efficiency criterion called rapidity which reflects the idea that exponential operations may be preferable if the language can be exponentially more succinct, and we demonstrate that the rapidity of each operation does not decrease from the i-th language in the second family to the i-th language in the first family, and then to the (i+1)-th language in the first family. Furthermore, we develop a compiler for the last language in the first family (i = ∞). Empirical results show that the compiler significantly advances the compiling efficiency of canonical representations. In fact, its compiling efficiency is comparable with that of the state-of-the-art compilers of non-canonical representations. We also provide a compiler for the i-th language in the first family by translating the last language in the first family into the i-th language (i < ∞). Empirical results show that we can sometimes use the i-th language instead of the last language without any obvious loss of space efficiency.
26
Olatunji, Ezekiel Kolawole, John B. Oladosu, Odetunji A. Odejobi e Stephen O. Olabiyisi. "Design and implementation of an African native language-based programming language". International Journal of Advances in Applied Sciences 10, n. 2 (1 giugno 2021): 171. http://dx.doi.org/10.11591/ijaas.v10.i2.pp171-177.
Testo completoAbstract (sommario):
<p>Most of the existing high level programming languages havehitherto borrowed their lexical items from human languages including European and Asian languages. However, there is paucity of research information on programming languages developed with the lexicons of an African indigenous language. This research explored the design and implementation of an African indigenous language-based programming language using Yoruba as case study. Yoruba is the first language of over 30 million people in the south-west of Nigeria, Africa; and is spoken by over one hundred million people world-wide. It is hoped, as established by research studies, that making computer programming possible in one’s mother tongue will enhance computer-based problem-solving processes by indigenous learners and teachers. The alphabets and reserved words of the programming language were respectively formed from the basic Yoruba alphabets and standard Yoruba words. The lexical items and syntactic structures of the programming language were designed with appropriate regular expressions and context-free grammars, using Backus-Naur Form (BNF) notations. A prototype implementation of the programming language was carried out as a source-to-source, 5-pass compiler. QBasic within QB64 IDE was the implementation language. The results from implementation showed functional correctness and effectiveness of the developed programming language. Thus lexical items of a programming language need not be borrowed exclusively from European and Asian languages, they can and should be borrowed from most African native languages. Furthermore, the developed native language programming language can be used to introduce computer programming to indigenous pupils of primary and junior secondary schools.</p>
27
Wardak, Abdullah A. "Interfacing C and TMS320C6713 Assembly Language (Part II)". WSEAS TRANSACTIONS ON COMPUTERS 20 (27 aprile 2021): 74–81. http://dx.doi.org/10.37394/23205.2021.20.9.
Testo completoAbstract (sommario):
In this paper, an interfacing of C and the assembly language of TMS320C6713 is presented. Similarly, interfacing of C with the assembly language of Motorola 68020 (MC68020) microprocessor is also presented for comparison. However, it should be noted that the way the C compiler passes arguments from the main function in C to the TMS320C6713 assembly language subroutine is totally different from the way the C compiler passes arguments in a conventional microprocessor such as MC68020. Therefore, it is very important for a user of the TMS320C6713-based system to properly understand and follow the register conventions and stack operation when interfacing C with the TMS320C6713 assembly language subroutine. This paper describes the application of special registers and stack in the interfacing of these programming languages. Working examples of C and their implementation in the TMS320C6713 assembly language are described in detail. Finally, the concept presented in this paper has been tested extensively by examining different examples under various conditions and has proved highly reliable in operation.
28
KIRCHNER, HÉLÈNE, e PIERRE-ETIENNE MOREAU. "Promoting rewriting to a programming language: a compiler for non-deterministic rewrite programs in associative-commutative theories". Journal of Functional Programming 11, n. 2 (marzo 2001): 207–51. http://dx.doi.org/10.1017/s0956796800003907.
Testo completoAbstract (sommario):
First-order languages based on rewrite rules share many features with functional languages, but one difference is that matching and rewriting can be made much more expressive and powerful by incorporating some built-in equational theories. To provide reasonable programming environments, compilation techniques for such languages based on rewriting have to be designed. This is the topic addressed in this paper. The proposed techniques are independent from the rewriting language, and may be useful to build a compiler for any system using rewriting modulo Associative and Commutative (AC) theories. An algorithm for many-to-one AC matching is presented, that works efficiently for a restricted class of patterns. Other patterns are transformed to fit into this class. A refined data structure, namely compact bipartite graph, allows encoding of all matching problems relative to a set of rewrite rules. A few optimisations concerning the construction of the substitution and of the reduced term are described. We also address the problem of non-determinism related to AC rewriting, and show how to handle it through the concept of strategies. We explain how an analysis of the determinism can be performed at compile time, and we illustrate the benefits of this analysis for the performance of the compiled evaluation process. Then we briefly introduce the ELAN system and its compiler, in order to give some experimental results and comparisons with other languages or rewrite engines.
29
Marowka, Ami. "Execution Model of Three Parallel Languages: OpenMP, UPC and CAF". Scientific Programming 13, n. 2 (2005): 127–35. http://dx.doi.org/10.1155/2005/914081.
Testo completoAbstract (sommario):
The aim of this paper is to present a qualitative evaluation of three state-of-the-art parallel languages: OpenMP, Unified Parallel C (UPC) and Co-Array Fortran (CAF). OpenMP and UPC are explicit parallel programming languages based on the ANSI standard. CAF is an implicit programming language. On the one hand, OpenMP designs for shared-memory architectures and extends the base-language by using compiler directives that annotate the original source-code. On the other hand, UPC and CAF designs for distribute-shared memory architectures and extends the base-language by new parallel constructs. We deconstruct each language into its basic components, show examples, make a detailed analysis, compare them, and finally draw some conclusions.
30
Liu, Amanda, Gilbert Bernstein, Adam Chlipala e Jonathan Ragan-Kelley. "A Verified Compiler for a Functional Tensor Language". Proceedings of the ACM on Programming Languages 8, PLDI (20 giugno 2024): 320–42. http://dx.doi.org/10.1145/3656390.
Testo completoAbstract (sommario):
Producing efficient array code is crucial in high-performance domains like image processing and machine learning. It requires the ability to control factors like compute intensity and locality by reordering computations into different stages and granularities with respect to where they are stored. However, traditional pure, functional tensor languages struggle to do so. In a previous publication, we introduced ATL as a pure, functional tensor language capable of systematically decoupling compute and storage order via a set of high-level combinators known as reshape operators. Reshape operators are a unique functional-programming construct since they manipulate storage location in the generated code by modifying the indices that appear on the left-hand sides of storage expressions. We present a formal correctness proof for an implementation of the compilation algorithm, marking the first verification of a lowering algorithm targeting imperative loop nests from a source functional language that enables separate control of compute and storage ordering. One of the core difficulties of this proof required properly formulating the complex invariants to ensure that these storage-index remappings were well-formed. Notably, this exercise revealed a soundness bug in the original published compilation algorithm regarding the truncation reshape operators. Our fix is a new type system that captures safety conditions that were previously implicit and enables us to prove compiler correctness for well-typed source programs. We evaluate this type system and compiler implementation on a range of common programs and optimizations, including but not limited to those previously studied to demonstrate performance comparable to established compilers like Halide.
31
Clément, Basile, e Albert Cohen. "End-to-end translation validation for the halide language". Proceedings of the ACM on Programming Languages 6, OOPSLA1 (8 dicembre 2022): 1–30. http://dx.doi.org/10.1145/3527328.
Testo completoAbstract (sommario):
This paper considers the correctness of domain-specific compilers for tensor programming languages through the study of Halide, a popular representative. It describes a translation validation algorithm for affine Halide specifications, independently of the scheduling language. The algorithm relies on “prophetic” annotations added by the compiler to the generated array assignments. The annotations provide a refinement mapping from assignments in the generated code to the tensor definitions from the specification. Our implementation leverages an affine solver and a general SMT solver, and scales to complete Halide benchmarks.
32
Lecoeur, Bastien, Hasan Mohsin e Alastair F. Donaldson. "Program Reconditioning: Avoiding Undefined Behaviour When Finding and Reducing Compiler Bugs". Proceedings of the ACM on Programming Languages 7, PLDI (6 giugno 2023): 1801–25. http://dx.doi.org/10.1145/3591294.
Testo completoAbstract (sommario):
We introduce program reconditioning, a method for allowing program generation and differential testing to be used to find miscompilation bugs, and test-case reduction to be used to simplify bug-triggering programs, even when (a) the programming language of interest features undefined behaviour (UB) and (b) no tools exist to detect and avoid this UB. We present two program generation tools based on our reconditioning idea: GLSLsmith for the OpenGL Shading Language (GLSL), a widely-used language for graphics programming, and WGSLsmith for the WebGPU Shading Language (WGSL), a new language for web-based graphics rendering. GLSL features many UBs, but unlike for languages such as C and C++ no tools exist to detect them automatically. While the WGSL language specification features very limited UB, early WGSL implementations do exhibit UB, for reasons of initial implementation simplicity, making it challenging to test them to quickly detect and eliminate unrelated miscompilation bugs. Thanks to reconditioning, we show that GLSLsmith and WGSLsmith allow differential testing and test-case reduction to be applied to compilers for GLSL and WGSL for the first time, despite the unavailability of UB detection techniques for these languages. Through a large testing campaign, we have found 24 and 33 bugs in GLSL and WGSL compilers, respectively. We present experiments showing that when reconditioning is disabled, compiler testing leads to a high rate of test programs that appear to trigger miscompilation bugs, but actually just feature UB. We also present a novel approach to managing floating-point roundoff error using reconditioning, implemented for both GLSL and WGSL.
33
Bourke, Timothy, Basile Pesin e Marc Pouzet. "Verified Compilation of Synchronous Dataflow with State Machines". ACM Transactions on Embedded Computing Systems 22, n. 5s (9 settembre 2023): 1–26. http://dx.doi.org/10.1145/3608102.
Testo completoAbstract (sommario):
Safety-critical embedded software is routinely programmed in block-diagram languages. Recent work in the Vélus project specifies such a language and its compiler in the Coq proof assistant. It builds on the CompCert verified C compiler to give an end-to-end proof linking the dataflow semantics of source programs to traces of the generated assembly code. We extend this work with switched blocks, shared variables, reset blocks, and state machines; define a relational semantics to integrate these block- and mode-based constructions into the existing stream-based model; adapt the standard source-to-source rewriting scheme to compile the new constructions; and reestablish the correctness theorem.
34
Isaeva, G. N., N. N. Teodorovich e Y. Y. Sidorov. "Tendencies of development of languages of programming of the high level". Informacionno-technologicheskij vestnik 14, n. 4 (30 dicembre 2017): 117–25. http://dx.doi.org/10.21499/2409-1650-2017-4-117-125.
Testo completoAbstract (sommario):
The main directions of the development of modern high-level programming languages (HL PL) and their evolutionary development are considered in the article. The statistics are presented for the HL PL, which are key in the framework of various programming paradigms, based on the data of modern electronic resources. A tendency is shown to obliterate the boundaries between the strict classification of the HL PL, as belonging to different computational models underlying the development of the language. It is shown that the main reason for the popularity of scripting languages and languages of reactive programming is related to the scale of solved economic problems, the mass coverage of all spheres of the economy by network structures, and also the desire of developers to have a simple, understandable and universal software development tool.
35
Meil, Doug. "Lessons from PL/I: A Most Ambitious Programming Language". Communications of the ACM 66, n. 11 (20 ottobre 2023): 6–7. http://dx.doi.org/10.1145/3623564.
Testo completoAbstract (sommario):
The Communications website, https://cacm.acm.org, features more than a dozen bloggers in the BLOG@CACM community. In each issue of Communications , we'll publish selected posts or excerpts. twitter Follow us on Twitter at http://twitter.com/blogCACM https://cacm.acm.org/blogs/blog-cacm PL/I stands for Programming Language 1, and its aim was to be the Highlander of programming languages.
36
KIPPS, JAMES R. "ADVANCED PARSER-GENERATION TECHNOLOGY FOR AI LANGUAGE APPLICATIONS". International Journal on Artificial Intelligence Tools 01, n. 04 (dicembre 1992): 545–61. http://dx.doi.org/10.1142/s0218213092000053.
Testo completoAbstract (sommario):
A side effect of AI research is the development of programming languages as vehicles for experimentation and demonstration of concepts. These AI languages generally require some form of parser front end, which can be nontrivial to build. Parser generators can ease the task of language development, but commonly available generators use parsing technologies that severely constrain the level of syntactic sophistication, such as allowing at most one symbol of look ahead. Further, these generators are most often targeted for C and Ada applications; parser generators for LISP applications are not widely available. The RAND Advanced Compiler Kit (RACK) is a parser generator for generalized LR parsing and is suitable for AI applications. RACK parsers are unique in their ability to recognize non-LR(k) languages, as well as LR(k) languages for k > 1. RACK is implemented in C and is upwardly compatible with YACC, a widely used parser generator for C applications. RACK generates parsers that interface with C or Common Lisp. RACK also includes features such as arbitrary look-ahead, multiple start symbols, a scanner generator, and a grammar interpreter. In this paper, I describe RACK, its parsing technology, and significant features; I also report performance results comparing RACK to YACC.
37
Filman, Robert E., e Paul H. Morris. "Compiling Knowledge-Based Systems to Ada: The PrkAda ProTalk Compiler". International Journal on Artificial Intelligence Tools 06, n. 03 (settembre 1997): 325–39. http://dx.doi.org/10.1142/s0218213097000189.
Testo completoAbstract (sommario):
This paper describes the implementation of the ProTalk compiler for PrkAda. An important component of the ProKappa system is its multi-paradigm, mixed-rule/imperative language, ProTalk. ProTalk combines elements of backtracking AI languages such as Prolog with imperative constructs such as conditionals, iteration, assignment, and subprogram invocation. Our implementation illustrates the use of generators to achieve a Prolog-like semantics, and the possibility (and difficulties) of employing such mechanisms in Ada.
38
Ciric, Miroslav, e Svetozar Rancic. "Parsing in different languages". Facta universitatis - series: Electronics and Energetics 18, n. 2 (2005): 299–307. http://dx.doi.org/10.2298/fuee0502299c.
Testo completoAbstract (sommario):
A compiler is a translator that accepts as input formatted source file or files, and produces as output a file that may be run directly on a computer. Given the same ANSI C++ compliant input file, two different ANSI C++ compliant compilers running on the same operating system produce two different executable programs that should execute in exactly the same way. To some degree, this is achieved by the standardization of the C++ language, but it is also possible because computer programming languages like C++ can be compiled using reliable technologies with long traditions and understood characteristics. LALR(k), as practical version of LR, is such reliable technology for parsing. Traditional LALR(1) tool YACC has proved his value during years of successful applications. Nowadays there are a few commercial and noncommercial alternatives that are very interesting and promising. This paper will examine some of the them with ability of parsing in different programming languages.
39
Kovačević, Željko, Marjan Mernik, Miha Ravber e Matej Črepinšek. "From Grammar Inference to Semantic Inference—An Evolutionary Approach". Mathematics 8, n. 5 (18 maggio 2020): 816. http://dx.doi.org/10.3390/math8050816.
Testo completoAbstract (sommario):
This paper describes a research work on Semantic Inference, which can be regarded as an extension of Grammar Inference. The main task of Grammar Inference is to induce a grammatical structure from a set of positive samples (programs), which can sometimes also be accompanied by a set of negative samples. Successfully applying Grammar Inference can result only in identifying the correct syntax of a language. With the Semantic Inference a further step is realised, namely, towards inducing language semantics. When syntax and semantics can be inferred, a complete compiler/interpreter can be generated solely from samples. In this work Evolutionary Computation was employed to explore and exploit the enormous search space that appears in Semantic Inference. For the purpose of this research work the tool LISA.SI has been developed on the top of the compiler/interpreter generator tool LISA. The first results are encouraging, since we were able to infer the semantics only from samples and their associated meanings for several simple languages, including the Robot language.
40
CASEAU, YVES, FRANÇOIS-XAVIER JOSSET e FRANÇOIS LABURTHE. "CLAIRE: combining sets, search and rules to better express algorithms". Theory and Practice of Logic Programming 2, n. 6 (novembre 2002): 769–805. http://dx.doi.org/10.1017/s1471068401001363.
Testo completoAbstract (sommario):
This paper presents a programming language which includes paradigms that are usually associated with declarative languages, such as sets, rules and search, into an imperative (functional) language. Although these paradigms are separately well known and are available under various programming environments, the originality of the CLAIRE language comes from the tight integration, which yields interesting run-time performances, and from the richness of this combination, which yields new ways in which to express complex algorithmic patterns with few elegant lines. To achieve the opposite goals of a high abstraction level (conciseness and readability) and run-time performance (CLAIRE is used as a C++ preprocessor), we have developed two kinds of compiler: first, a pattern pre-processor handles iterations over both concrete and abstract sets (data types and program fragments), in a completely user-extensible manner; secondly, an inference compiler transforms a set of logical rules into a set of functions (demons that are used through procedural attachment).
41
Koseska-Toszewa, Violetta, e Roman Roszko. "Języki słowiańskie i litewski w korpusach równoległych Clarin-PL". Studia z Filologii Polskiej i Słowiańskiej 51 (31 dicembre 2016): 191–217. http://dx.doi.org/10.11649/sfps.2016.011.
Testo completoAbstract (sommario):
Slavic languages and the Lithuanian language in the Clarin-PL parallel corporaThe Clarin Eric and Clarin-PL strategic scientific purpose is to support humanistic research in a multicultural and multilingual Europe. Polish researchers put the emphasis on building a bridge between the Polish language and Polish linguistic technologies and other European languages and their linguistic technologies. So far, the Polish scientific community has mainly focused on Polish-English connections. Clarin-PL has been developing the first and only multilingual corpora of the Polish language in conjunction with other Slavic languages and the Lithuanian language: the Polish-Bulgarian-Russian Parallel Corpus and the Polish- Lithuanian Parallel Corpus. The parallel corpora created by the ISS PAS Corpus Linguistics and Semantics Team break through the existing “canons” and allow scientists access to interlinked multilingual language resources – in the first phase limited to the languages of the three Slavic groups and the Lithuanian language. In the article, the authors present very detailed information on their original system of the semantic annotation of scope quantification in multilingual parallel corpora, hitherto unused in the subject literature. Due to the system’s originality, the semantic annotation is carried out manually. Identification of particular values of scope quantification in a sentence and the hereby presented attempts of its recording are supported by long-term research conducted by an international team of linguists and computer scientists / mathematicians developing the issue of quantification of names, time and aspect in natural languages. Języki słowiańskie i litewski w korpusach równoległych Clarin-PLStrategicznym celem naukowym Clarin ERIC i Clarin-PL jest wspieranie badań humanistycznych w wielokulturowej i wielojęzycznej Europie. Dla polskich badaczy ważna jest budowa pomostu między językiem polskim, polskimi technologiami językowymi a innymi językami europejskimi i na ich rzecz opracowanymi technologiami językowymi. Dotychczas w nauce polskiej największy nacisk był kładziony na powiązania polsko-angielskie. Clarin-PL opracowuje zatem pierwsze jak dotąd wielojęzyczne korpusy języka polskiego w zestawieniu z innymi językami słowiańskimi oraz z językiem litewskim: Korpus równoległy polsko-bułgarsko-rosyjski i Korpus równoległy polsko-litewski. Tworzone przez Zespół Lingwistyki Korpusowej i Semantyki (IS PAN) korpusy równoległe przełamują dotychczasowe „kanony” i udostępniają nauce powiązane wielojęzyczne zasoby – w pierwszym etapie ograniczone do języków trzech grup słowiańskich oraz języka litewskiego. W artykule autorzy przedstawiają bardzo szczegółową informację o zastosowanej po raz pierwszy w literaturze przedmiotu anotacji semantycznej dotyczącej kwantyfikacji zakresowej w wielojęzycznych korpusach równoległych. Z powodu swojego rozległego zakresu i nowatorstwa ta anotacja semantyczna jest nanoszona ręcznie. Identyfikacja poszczególnych wartości kwantyfikacji zakresowej w zdaniu oraz przedstawiane tu próby jej zapisu są poparte wieloletnimi badaniami międzynarodowego zespołu lingwistów i matematyków-informatyków opracowujących zagadnienie kwantyfikacji imion, czasu i aspektu w językach naturalnych.
42
Dagaev, Dmitry Viktorovich. "Restrictive language semantics in the Multioberon system". Программные системы и вычислительные методы, n. 1 (gennaio 2023): 26–41. http://dx.doi.org/10.7256/2454-0714.2023.1.36217.
Testo completoAbstract (sommario):
The Oberon-based language and systems in implementation demonstrate a minimalist approach to achieving reliability, significantly different from most software systems that seek to maximize the number of supported functions. The requirements for critical systems for Category A nuclear power plants prohibit the use of even more programming practices. In order to meet the category A requirement of a stable number of iterations, the use of conditional loop operators is prohibited. To ensure ergodicity, the prohibition of the use of dynamic memory and recursion is used. A buffer overflow type vulnerability is closed by prohibiting the system operations module SYSTEM. Restrictions can be set to identify the problem of a fragile base class, type change operations, and the use of nested procedures. It is noted that the transition to the Oberon-07 dialect mainly concerned additional restrictions and fits well into the framework of restrictive semantics. Instead of languages and dialects for each set of requirements, the author proposes an approach of restrictive semantics, in which one language with a system of restrictions is used. A single RESTRICT statement has been introduced into the language as a declaration of restrictions on this module. The Multioberon compiler is implemented with one frontend, including a system of restrictions, and several replaceable backends. The syntactic analysis of the compiler is demonstrated by examples. The strategy of scaling the compiler depending on the system requirements is shown. The novelty of the restrictive semantics approach is the achievement of a set of minimum necessary properties that meet the requirements for the system. The use of the "from limitations" approach by system developers is an advantage, because it declares the really necessary properties of the system, linked to the requirements.
43
SOJKA-MASZTALERZ, HELENA. "ZOOINWEKTYWY W RÓŻNYCH ODMIANACH JĘZYKA POLSKIEGO I UKRAIŃSKIEGO". Studia Ukrainica Posnaniensia 9, n. 2 (31 dicembre 2021): 73–84. http://dx.doi.org/10.14746/sup.2021.9.2.06.
Testo completoAbstract (sommario):
Appelatives having an insulting function have been used since the earliest times. Nowadays, they are present in standard language and in substandard types of language (sociolects). The aim of the article is to show that animal-related invectives are more and more frequently usedin order to express negative emotions towards the receiver. In Polish and Ukrainian, the number of animal-related invectives increases but also semantics of the words broaden as the meaning of those words originally referred to the name of a given animal. The lexemes were analyzed and divided into two groups: names of animals that have several meanings, but some of them overlap (pl. baran – ukr. бapaн, pl. cap – ukr. цaп, pl. krowa – ukr. кopoвa) and names that have completely different meanings in the two languages (pl. wydra – ukr. видpa, pl. larwa – ukr. ляpвa, pl. szakal – ukr. шaкaл).
44
Bourke, Timothy, Paul Jeanmaire, Basile Pesin e Marc Pouzet. "Verified Lustre Normalization with Node Subsampling". ACM Transactions on Embedded Computing Systems 20, n. 5s (31 ottobre 2021): 1–25. http://dx.doi.org/10.1145/3477041.
Testo completoAbstract (sommario):
Dataflow languages allow the specification of reactive systems by mutually recursive stream equations, functions, and boolean activation conditions called clocks. Lustre and Scade are dataflow languages for programming embedded systems. Dataflow programs are compiled by a succession of passes. This article focuses on the normalization pass which rewrites programs into the simpler form required for code generation. Vélus is a compiler from a normalized form of Lustre to CompCert’s Clight language. Its specification in the Coq interactive theorem prover includes an end-to-end correctness proof that the values prescribed by the dataflow semantics of source programs are produced by executions of generated assembly code. We describe how to extend Vélus with a normalization pass and to allow subsampled node inputs and outputs. We propose semantic definitions for the unrestricted language, divide normalization into three steps to facilitate proofs, adapt the clock type system to handle richer node definitions, and extend the end-to-end correctness theorem to incorporate the new features. The proofs require reasoning about the relation between static clock annotations and the presence and absence of values in the dynamic semantics. The generalization of node inputs requires adding a compiler pass to ensure the initialization of variables passed in function calls.
45
Getov, Vladimir, Paul Gray, Sava Mintchev e Vaidy Sunderam. "Multi-Language Programming Environments for High Performance Java Computing". Scientific Programming 7, n. 2 (1999): 139–46. http://dx.doi.org/10.1155/1999/975837.
Testo completoAbstract (sommario):
Recent developments in processor capabilities, software tools, programming languages and programming paradigms have brought about new approaches to high performance computing. A steadfast component of this dynamic evolution has been the scientific community’s reliance on established scientific packages. As a consequence, programmers of high‐performance applications are reluctant to embrace evolving languages such as Java. This paper describes the Java‐to‐C Interface (JCI) tool which provides application programmers wishing to use Java with immediate accessibility to existing scientific packages. The JCI tool also facilitates rapid development and reuse of existing code. These benefits are provided at minimal cost to the programmer. While beneficial to the programmer, the additional advantages of mixed‐language programming in terms of application performance and portability are addressed in detail within the context of this paper. In addition, we discuss how the JCI tool is complementing other ongoing projects such as IBM’s High‐Performance Compiler for Java (HPCJ) and IceT’s metacomputing environment.
46
Belyakov, K. V., e N. N. Datsun. "SYSTEMATIC MAPPING STUDY: THE USE OF TRANSPILERS". Vestnik komp'iuternykh i informatsionnykh tekhnologii, n. 229 (luglio 2023): 3–10. http://dx.doi.org/10.14489/vkit.2023.07.pp.003-010.
Testo completoAbstract (sommario):
A systematic mapping of the literature on the topic of transpiler use was conducted. Research questions addressing the research topic have been compiled. A search for publications narrating the topic of transpilers in various digital sources was conducted. The selection of unique and relevant publications was performed. A quantitative distribution of works by type of publication channel, geography, and quantitative composition of authors was performed. Based on the obtained sample of publications the answers to the research questions were obtained. The terms used in place of the term "Transpiler" were researched. The most common synonym turned out to be the term "Source-to-source compiler". The fields of application of transpiling were investigated. Most often transpilers were used for code generation, computation, and optimization purposes. The programming languages most commonly encountered in research were also examined. The most common programming languages were C/C++ and Python. It was also noted that JavaScript is never the source language of transpilation. Correlations between research questions were examined. A correlation was found between research questions of synonyms and fields of application, where the names transpiler and transcompiler are more often used in the field of code generation. A connection was also found between research questions of synonyms and programming languages, where transpilers used within the same programming language are more often referred to as source-to-source compiler. A growing trend in the number of studies on transpiler topics was demonstrated. The prospects of the work were also identified – the classification of programming languages by their level (low, high) and the study of correlation with other classifications.
47
Knies, Allan, Matthew O'keefe e Tom Macdonald. "High Performance Fortran: A Practical Analysis". Scientific Programming 3, n. 3 (1994): 187–99. http://dx.doi.org/10.1155/1994/150306.
Testo completoAbstract (sommario):
The recently released high performance Fortran forum (HPFF) proposal has stirred much interest in the high performance computing industry. HPFF's most important design goal is to create a language that has source code portability and that achieves high performance on single instruction multiple data (SIMD), distributed-memory multiple instruction multiple data (MIMD), and shared-memory MIMD architectures. The HPFF proposal brings to the forefront many questions about design of portable and efficient languages for parallel machines. In this article, we discuss issues that need to be addressed before an efficient production quality compiler will be available for any such language. We examine some specific issues that are related to HPF's model of computation and analyze several implementation issues. We also provide some results from another data parallel compiler to help gain insight on some of the implementation issues that are relevant to HPF. Finally, we provide a summary of options currently available for application developers in industry.
48
MARANGET, LUC. "Warnings for pattern matching". Journal of Functional Programming 17, n. 3 (15 febbraio 2007): 387–421. http://dx.doi.org/10.1017/s0956796807006223.
Testo completoAbstract (sommario):
AbstractWe examine the ML pattern-matching anomalies of useless clauses and non-exhaustive matches. We state the definition of these anomalies, building upon pattern matching semantics, and propose a simple algorithm to detect them. We have integrated the algorithm in the Objective Caml compiler, but we show that the same algorithm is also usable in a non-strict language such as Haskell. Or-patterns are considered for both strict and non-strict languages.
49
Jones, Simon L. Peyton. "Implementing lazy functional languages on stock hardware: the Spineless Tagless G-machine". Journal of Functional Programming 2, n. 2 (aprile 1992): 127–202. http://dx.doi.org/10.1017/s0956796800000319.
Testo completoAbstract (sommario):
AbstractThe Spineless Tagless G-machine is an abstract machine designed to support non-strict higher-order functional languages. This presentation of the machine falls into three parts. Firstly, we give a general discussion of the design issues involved in implementing non-strict functional languages. Next, we present the STG language, an austere but recognizably-functional language, which as well as a denotational meaning has a well-defined operational semantics. The STG language is the ‘abstract machine code’ for the Spineless Tagless G-machine. Lastly, we discuss the mapping of the STG language onto stock hardware. The success of an abstract machine model depends largely on how efficient this mapping can be made, though this topic is often relegated to a short section. Instead, we give a detailed discussion of the design issues and the choices we have made. Our principal target is the C language, treating the C compiler as a portable assembler.
50
Pompougnac, Hugo, Ulysse Beaugnon, Albert Cohen e Dumitru Potop Butucaru. "Weaving Synchronous Reactions into the Fabric of SSA-form Compilers". ACM Transactions on Architecture and Code Optimization 19, n. 2 (30 giugno 2022): 1–25. http://dx.doi.org/10.1145/3506706.
Testo completoAbstract (sommario):
We investigate the programming of reactive systems combining closed-loop control with performance-intensive components such as Machine Learning (ML). Reactive control systems are often safety-critical and associated with real-time execution requirements, a domain of predilection for synchronous programming languages. Extending the high levels of assurance found in reactive control systems to computationally intensive code remains an open issue. We tackle it by unifying concepts and algorithms from synchronous languages with abstractions commonly found in general-purpose and ML compilers. This unification across embedded and high-performance computing enables a high degree of reuse of compiler abstractions and code. We first recall commonalities between dataflow synchronous languages and the static single assignment (SSA) form of general-purpose/ML compilers. We highlight the key mechanisms of synchronous languages that SSA does not cover—denotational concepts such as synchronizing computations with an external time base, cyclic and reactive I/O, as well as the operational notions of relaxing control flow dominance and the modeling of absent values. We discover that initialization-related static analyses and code generation aspects can be fully decoupled from other aspects of synchronous semantics such as memory management and causality analysis, the latter being covered by existing dominance-based algorithms of SSA-form compilers. We show how the SSA form can be seamlessly extended to enable all SSA-based transformations and optimizations on reactive programs with synchronous concurrency. We derive a compilation flow suitable for both high-performance and reactive aspects of a control application, by embedding the Lustre dataflow synchronous language into the SSA-based MLIR/LLVM compiler infrastructure. This allows the modeling of signal processing and deep neural network inference in the (closed) loop of feedback-directed control systems. With only minor efforts leveraging the MLIR infrastructure, the generated code matches or outperforms state-of-the-art synchronous language compilers on computationally intensive ML applications.