scholarly journals DOMAIN-SPECIFIC TRANSITION SYSTEMS AND THEIR APPLICATION TO A FORMAL DEFINITION OF A MODEL PROGRAMMING LANGUAGE

2014 ◽  
Author(s):  
Igor Anureev ◽  
Keyword(s):  
Programming Language ◽  
Formal Definition ◽  
Transition Systems ◽  
Domain Specific ◽  
Definition Of

Formal definition of programming language standards

2003 ◽  
Vol 38 (8) ◽  
pp. 20-21 ◽  
Author(s):  
C. Pronk ◽  
M. Schönhacker
Keyword(s):  
Programming Language ◽  
Formal Definition ◽  
Definition Of

scholarly journals Type stability in Julia: avoiding performance pathologies in JIT compilation

2021 ◽  
Vol 5 (OOPSLA) ◽  
pp. 1-26
Author(s):  
Artem Pelenitsyn ◽  
Julia Belyakova ◽  
Benjamin Chung ◽  
Ross Tate ◽  
Jan Vitek
Keyword(s):  
Programming Language ◽  
Corpus Analysis ◽  
Formal Definition ◽  
Compiler Optimizations ◽  
Definition Of ◽  
High Level ◽  
Jit Compilation

As a scientific programming language, Julia strives for performance but also provides high-level productivity features. To avoid performance pathologies, Julia users are expected to adhere to a coding discipline that enables so-called type stability. Informally, a function is type stable if the type of the output depends only on the types of the inputs, not their values. This paper provides a formal definition of type stability as well as a stronger property of type groundedness, shows that groundedness enables compiler optimizations, and proves the compiler correct. We also perform a corpus analysis to uncover how these type-related properties manifest in practice.

scholarly journals LANGUAGE-DRIVEN SYSTEM DESIGN

2004 ◽  
Vol 14 (06) ◽  
pp. 625-663 ◽  
Author(s):  
S. MAUW ◽  
W. T. WIERSMA ◽  
T. A. C. WILLEMSE
Keyword(s):  
Software Engineering ◽  
System Design ◽  
Problem Definition ◽  
Formal Definition ◽  
Traffic Lights ◽  
Domain Specific ◽  
Driven System ◽  
Formal Problem ◽  
Definition Of ◽  
Under Construction

Studies have shown significant benefits of the use of Domain-Specific Languages (DSL) in software engineering. We discuss a software engineering methodology that fully exploits these benefits. The methodology, called the Language-Driven Approach (LDA), is centred around the design of a DSL. It prescribes a staged development of a DSL, which is tailored to the system-under-construction. On the basis of a domain analysis, a formal definition of the problem is obtained. This formal problem definition contains all the relevant ingredients for designing the syntax, the semantics and the pragmatics, which together comprise the DSL. The methodology is illustrated by an elaborate example dealing with the problem of regulating traffic lights at a traffic junction.

Towards Open Graphical Tool-Building Framework

2011 ◽  
Vol 43 (1) ◽  
pp. 80-87 ◽  
Author(s):  
Edgars Rencis ◽  
Janis Barzdins ◽  
Sergejs Kozlovics
Keyword(s):  
Deep Understanding ◽  
Easy Task ◽  
Domain Specific ◽  
Activity Diagrams ◽  
Graphical Tool ◽  
One Step ◽  
Uml Activity Diagrams ◽  
Definition Of ◽  
Tool Building

Towards Open Graphical Tool-Building Framework Nowadays, there are many frameworks for developing domain-specific tools. However, if we want to create a really sophisticated tool with specific functionality requirements, it is not always an easy task to do. Although tool-building platforms offer some means for extending the tool functionality and accessing it from external applications, it usually requires a deep understanding of various technical implementation details. In this paper we try to go one step closer to a really open graphical tool-building framework that would allow both to change the behavior of the tool and to access the tool from the outside easily. We start by defining a specialization of metamodels which is a great and powerful facility itself. Then we go on and show how this can be applied in the field of graphical domain-specific tool building. The approach is demonstrated on an example of a subset of UML activity diagrams. The benefits of the approach are also clearly indicated. These include a natural and intuitive definition of tools, a strict logic/presentation separation and the openness for extensions as well as for external applications.

Cubical Agda: A dependently typed programming language with univalence and higher inductive types

2021 ◽  
Vol 31 ◽  
Author(s):  
ANDREA VEZZOSI ◽  
ANDERS MÖRTBERG ◽  
ANDREAS ABEL
Keyword(s):  
Programming Language ◽  
Type Theory ◽  
Type Checking ◽  
Dependent Type Theory ◽  
Wide Range ◽  
General Schema ◽  
Direct Definition ◽  
Inductive Types ◽  
Definition Of ◽  
Cubical Type Theory

Abstract Proof assistants based on dependent type theory provide expressive languages for both programming and proving within the same system. However, all of the major implementations lack powerful extensionality principles for reasoning about equality, such as function and propositional extensionality. These principles are typically added axiomatically which disrupts the constructive properties of these systems. Cubical type theory provides a solution by giving computational meaning to Homotopy Type Theory and Univalent Foundations, in particular to the univalence axiom and higher inductive types (HITs). This paper describes an extension of the dependently typed functional programming language Agda with cubical primitives, making it into a full-blown proof assistant with native support for univalence and a general schema of HITs. These new primitives allow the direct definition of function and propositional extensionality as well as quotient types, all with computational content. Additionally, thanks also to copatterns, bisimilarity is equivalent to equality for coinductive types. The adoption of cubical type theory extends Agda with support for a wide range of extensionality principles, without sacrificing type checking and constructivity.

scholarly journals Students’ Understanding on Formal Definition of Limit

2021 ◽  
Vol 1752 (1) ◽  
pp. 012082
Author(s):  
Nurdin ◽  
S F Assagaf ◽  
F Arwadi
Keyword(s):  
Formal Definition ◽  
Definition Of
Sign in / Sign up

Export Citation Format

Share Document