Mokriš, Andrej · Brno University of Technology Digital Library (Brno University of Technology) · 2024
Rýchly vývoj programovacích jazykov priniesol radu praktických problémov, napríklad obmedzenú spätnú kompatibilitu. Časť týchto problémov môže byť riešená transpilátormi. Táto práca predstavuje základné koncepty z teórie formálnych jazykov, prekladačov a prístupov k syntaktickej analýze. Cieľom práce je navrhnúť a implementovať transpilátor, ktorý prekladá podmnožinu jazyka PHP do jazyka JavaScript.
Cited by 0Open access
Dave Cunningham, Rajesh Bordawekar, Vijay Saraswat · 2011
GPU architectures have emerged as a viable way of considerably improving performance for appropriate applications. Program fragments (kernels) appropriate for GPU execution can be implemented in CUDA or OpenCL and glued into an application via an API.
Cited by 66
James E. Hicks · DSpace@MIT (Massachusetts Institute of Technology) · 1988
The motivations for an abstract, diagrammatic signal processing language are presented along with a study of the semantics that such a language should have..D-7>ZCT, the proposed Digital Signal Processing Pictorial Language, is thoroughly described..D-7>ZCT has a diagrammatic representation with a corresponding textual representation. The diagrammatic representation explicitly shows the parallelism available in the procedures defined and is similar to the flow graphs used to depict signal processing algorithms by researchers in that field..D-7>ZCT is strongly typed, but type declarations are only required for proce- dures.
Cited by 1Open access
Christopher W. Fraser, David R. Hanson · 1983
Unifying programming and command languages is a promising idea that has yet to be thoroughly exploited. Most attempts at such unification have used Lisp or traditional languages, such as Pascal. This paper describes the command and programming language EZ, which attempts to unify command and programming languages by using high-level string-processing concepts, such as those in SNOBOL4 and Icon. EZ has particularly simple data abstractions that attempt to bridge the gap between the data abstractions of command languages and those of programming languages. This is accomplished by type fusion, which pushes the differences between some classes of types, such as strings and text files, out of the language and into the implementation. The language, its use, and its implementation are described.
Cited by 11
Christopher W. Fraser, David R. Hanson · ACM SIGPLAN Notices · 1983
Unifying programming and command languages is a promising idea that has yet to be thoroughly exploited. Most attempts at such unification have used Lisp or traditional languages, such as Pascal. This paper describes the command and programming language EZ , which attempts to unify command and programming languages by using high-level string-processing concepts, such as those in SNOBOL4 and Icon. EZ has particularly simple data abstractions that attempt to bridge the gap between the data abstractions of command languages and those of programming languages. This is accomplished by type fusion , which pushes the differences between some classes of types, such as strings and text files, out of the language and into the implementation. The language, its use, and its implementation are described.
Cited by 5Open access
EditorJournals and Conferences · OSF Preprints (OSF Preprints)
Features of Python programming language, one of the high-level programming languages, are discussed.
Cited by 0
Jonathan Parker · PRISM (University of Calgary) · 1998
A system for digital morphology is presented in which morphological operators are implemented as basic operation in a programming language, and where basic data types include pixels and images. The resulting language can be used effectively for prototyping morphological software and for teaching the principles.
Cited by 1Open access
R. J. Foulger · OpenGrey (Institut de l'Information Scientifique et Technique) · 1982
Cited by 2Open access
Giloi, W.K., Kessler, M., Schramm, A. · Publikationsdatenbank der Fraunhofer-Gesellschaft (Fraunhofer-Gesellschaft) · 1996
S.660-666
Cited by 7
Werner Purgathofer · Computers & Graphics · 1987
Cited by 1
Giloi Kessler Schramm, W. K. Giloi, M. Kessler et al. · 1995
The superior performance and cost-effectiveness of scalable, distributed memory parallel computers will only then become generally exploitable if the programming difficulties with such machines are overcome. We see the ultimate solution in high-level programming models and appropriate parallelizing compilers that allow the user to formulate a parallel program in terms of application-specific concepts, while low-level issues such as optimal data distribution and coordination of the parallel threads are handled by the compiler. High Performance Fortran (HPF) is a major step in that direction; however, HPF still lacks in the generality of computing domains needed to treat other than regular, data-parallel numerical applications. A more flexible and more abstract programming language for regular and irregular objectparallel applications is PROMOTER. PROMOTER allows the user to program for an application-oriented abstract machine rather than for particular architecture. The wide semantic ga...
Cited by 0
Ludovic Räss, Samuel Omlin, Ivan Utkin · 2026
We are developing differentiable multi-physics solvers for extreme-scale geophysical simulations on GPUs (∂GPU4GEO project). These solvers exploit the massive parallelism of graphics processing units to significantly accelerate computations in geodynamic and related modelling applications.As the hardware landscape evolves rapidly and GPUs are continuously enhanced with new capabilities, systematic performance benchmarking is required to better understand performance opportunities and limitations, particularly for complex workloads such as coupled Stokes and multi-physics solvers.The Julia programming language, together with the JuliaGPU GitHub organisation, provides a unified framework for GPU programming in a high-level language. Owing to its expressive syntax and flexible compiler infrastructure, Julia enables productive development of GPU-accelerated codes without compromising performance.We present performance benchmark results for GPUs from major vendors and assess their relative performance. We investigate benchmarks relevant for Geodynamics and ice flow codes, and consider forward and reverse passes on kernels as this is relevant for automatic gradient generation using automatic differentiation (AD). We further discuss performance per GPU price, which is relevant when evaluating the acquisition of local research computing infrastructure.
Cited by 0Open access
Gianluigi Folino, Giandomenico Spezzano · 2002
This paper describes CELLAR, a language for cellular programming which extends the cellular automata model through the concept of regions. Regions are spatiotemporal objects that define zones of the automaton (set of cells), containing interesting and meaningful data patterns or trends that can be defined as events. Each cell of the automaton can monitor regions for a given period and observe their evolution by global functions (max, min, sum etc.). Furthermore, each cell can have an associated attribute called its perception rating, that indicates how far that cell can 'see'. On the basis of this value and the cell's position in the cellular space, we can define the regions that are visible to the cell. Using these constructs, a cell can define significant events to extract data of interest in one or more regions and perform actions when an event is detected. In the paper, we show that regions simplify programming and allow the building of more complex models. After describing the main constructs of CELLAR, the paper illustrates the region-based programming model by describing the design of a parallel model of animal migration. Performance results of the model implemented on a Meiko CS-2 are also given.
Cited by 3
Zhaoyun Chen, Guo‐Ping Guo · arXiv (Cornell University) · 2019
Hybrid quantum-classical algorithms have drawn much attention because of their potential to realize the "quantum advantage" in noisy, intermediate-scale quantum (NISQ) devices. Here we introduce QRunes, a cross-platform quantum language for hybrid programming. QRunes can be compiled to various host backends, allowing the user to write portable quantum subprograms. The hybrid programming is based on the type system, which is used to decide where a statement should be run. We also introduce Qurator, a VSCode plugin that has QRunes language support and two host backends.
Cited by 0Open access
Endler, M. · Publikationsdatenbank der Fraunhofer-Gesellschaft (Fraunhofer-Gesellschaft) · 1993
Cited by 0
Brian Hie, Salvatore Candido, Zeming Lin et al. · bioRxiv (Cold Spring Harbor Laboratory) · 2022
Abstract Combining a basic set of building blocks into more complex forms is a universal design principle. Most protein designs have proceeded from a manual bottom-up approach using parts created by nature, but top-down design of proteins is fundamentally hard due to biological complexity. We demonstrate how the modularity and programmability long sought for protein design can be realized through generative artificial intelligence. Advanced protein language models demonstrate emergent learning of atomic resolution structure and protein design principles. We leverage these developments to enable the programmable design of de novo protein sequences and structures of high complexity. First, we describe a high-level programming language based on modular building blocks that allows a designer to easily compose a set of desired properties. We then develop an energy-based generative model, built on atomic resolution structure prediction with a language model, that realizes all-atom structure designs that have the programmed properties. Designing a diverse set of specifications, including constraints on atomic coordinates, secondary structure, symmetry, and multimerization, demonstrates the generality and controllability of the approach. Enumerating constraints at increasing levels of hierarchical complexity shows that the approach can access a combinatorially large design space.
Cited by 60Open access
F. Grossman, Robert J. Klerer, Melvin Klerer · 2003
A language system called the Automated Programmer automates a great deal of routine effort for scientific, engineering, and mathematical application programming. Its notation is modeled after conventional textbook mathematical representation, so that mathematical expressions can be entered just as they appear in conventional solution specifications. It uses a flexible vocabulary and syntax that emulates technical English. This approach enhances self-documentation, diminishes programming error, and eases maintainability and verifiability. System design is highly user-oriented, making the system easy to learn and use. Programs are input using a two-dimensional screen editor. Lexical restrictions are minimal, keyword synonyms are available, and various common synonymous syntactic structures are acceptable. Powerful input and output facilities are provided.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">></ETX>
Cited by 5
Peter Sewell, James J. Leifer, Keith Wansbrough et al. · Journal of Functional Programming · 2007
Abstract Existing languages provide good support for typeful programming of stand-alone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper, we discuss programming-language support for such systems, focussing on their typing and naming issues. We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately built programs. The main features are (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type safety of associated values, for example, values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility. These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language run-time from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries.
Cited by 40Open access
Cees Visser, Anton Eliëns · Digital Academic REpository of VU University Amsterdam (Vrije Universiteit Amsterdam) · 2000
Cited by 1
Gross, Lutz, Smillie, Jonathan, Davies, Matt · Queensland's institutional digital repository (The University of Queensland) · 2004
Computational models based on the solution of partial differential equations (PDEs) play a key role in Earth systems simulations. The software implementing these models depends on the discretisation method, data structures and the computer architecture. For this reason, it is difficult for scientists to implement new models without strong software engineering skills. In this paper, we present a computational modeling language (escript) based on the object-oriented scripting language (Python). This language, is designed to implement PDE-based models with a high degree of abstraction from the underlying discretization techniques and their implementation. The main components of escript are the Data class objects which handle data with a spatial distribution and the linearPDE class which define linear PDEs to be solved in each step of a time integration or non-linear iteration scheme. As an example we will discuss the solution of the Lame equation and the implementation of a quasi-static model for crustal fault systems.
Cited by 1