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 Learners Programming Language a Helping System for Introductory Programming Courses

2016 ◽  
Vol 35 (3) ◽  
pp. 347-358
Author(s):  
Muhammad Shumail Naveed ◽  
Muhammad Sarim ◽  
Kamran Ahsan
Keyword(s):  
Programming Languages ◽  
Programming Language ◽  
Retention Rate ◽  
Introductory Programming ◽  
Source Program ◽  
Definition Of ◽  
High Level ◽  
Novice Students ◽  
Introductory Programming Courses ◽  
Programming Courses

Programming is the core of computer science and due to this momentousness a special care is taken in designing the curriculum of programming courses. A substantial work has been conducted on the definition of programming courses, yet the introductory programming courses are still facing high attrition, low retention and lack of motivation. This paper introduced a tiny pre-programming language called LPL (Learners Programming Language) as a ZPL (Zeroth Programming Language) to illuminate novice students about elementary concepts of introductory programming before introducing the first imperative programming course. The overall objective and design philosophy of LPL is based on a hypothesis that the soft introduction of a simple and paradigm specific textual programming can increase the motivation level of novice students and reduce the congenital complexities and hardness of the first programming course and eventually improve the retention rate and may be fruitful in reducing the dropout/failure level. LPL also generates the equivalent high level programs from user source program and eventually very fruitful in understanding the syntax of introductory programming languages. To overcome the inherent complexities of unusual and rigid syntax of introductory programming languages, the LPL provide elementary programming concepts in the form of algorithmic and plain natural language based computational statements. The initial results obtained after the introduction of LPL are very encouraging in motivating novice students and improving the retention rate.

Migrating JAVA to Mobile Platforms through HAXE

2016 ◽  
pp. 240-268 ◽  
Author(s):  
Pablo Nicolás Díaz Bilotto ◽  
Liliana Favre
Keyword(s):  
Programming Language ◽  
Mobile Applications ◽  
Software Evolution ◽  
Wide Spectrum ◽  
The Other ◽  
Model Transformations ◽  
Mobile Platforms ◽  
Model Driven ◽  
Definition Of ◽  
High Level

Software developers face several challenges in deploying mobile applications. One of them is the high cost and technical complexity of targeting development to a wide spectrum of platforms. The chapter proposes to combine techniques based on MDA (Model Driven Architecture) with the HaXe language. The outstanding ideas behind MDA are separating the specification of the system functionality from its implementation on specific platforms, managing the software evolution, increasing the degree of automation of model transformations, and achieving interoperability with multiple platforms. On the other hand, HaXe is a very modern high level programming language that allows us to generate mobile applications that target all major mobile platforms. The main contributions of this chapter are the definition of a HaXe metamodel, the specification of a model-to-model transformation between Java and HaXe and, the definition of an MDA migration process from Java to mobile platforms.

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 Acute: High-level programming language design for distributed computation

2007 ◽  
Vol 17 (4-5) ◽  
pp. 547-612 ◽  
Author(s):  
PETER SEWELL ◽  
JAMES J. LEIFER ◽  
KEITH WANSBROUGH ◽  
FRANCESCO ZAPPA NARDELLI ◽  
MAIR ALLEN-WILLIAMS ◽  
...  
Keyword(s):  
Programming Language ◽  
Distributed System ◽  
Operational Semantics ◽  
Module Structure ◽  
Distributed Programming ◽  
Type Safety ◽  
Programming Language Design ◽  
Local Resources ◽  
Definition Of ◽  
High Level

AbstractExisting 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.

ISF: A Visual Formalism for Specifying Interconnection Styles for Software Design

1998 ◽  
Vol 08 (04) ◽  
pp. 517-540 ◽  
Author(s):  
Spiros Mancoridis
Keyword(s):  
Software Design ◽  
Deductive Database ◽  
Formal Definition ◽  
Simple Design ◽  
The Core ◽  
Custom Design ◽  
Database Technology ◽  
Definition Of ◽  
High Level ◽  
Visual Notation

We have developed a framework for specifying high-level software designs. The core of the framework is a very simple visual notation. This notation enables designers to document designs as labelled rectangles and directed edges. In addition to the notation, our framework features a supporting formalism, called ISF (Interconnection Style Formalism). This formalism enables designers to customize the simple design notation by specifying the type of entities, relations, legal configurations of entities and relations, as well as scoping rules of the custom notation. In this paper we present the formal definition of ISF and use ISF to specify two custom design notations. We also describe how ISF specifications, using deductive database technology, are used to generate supporting tools for these custom notations.

Research and Implementation on a Statistic Algorithm Based on Multidimensional Dynamic Reports

2013 ◽  
Vol 411-414 ◽  
pp. 102-105
Author(s):  
An Sheng Lu ◽  
Hui Xiu Jin ◽  
Zi Hui Li ◽  
Jing Li
Keyword(s):  
Programming Language ◽  
Strategic Decisions ◽  
Dynamic Data ◽  
The Future ◽  
Current Operation ◽  
Definition Of ◽  
High Level ◽  
Operation Status ◽  
Business Requirements ◽  
Good Report

The report presents information with dynamic data and various formats. It is the foundation of the basic business requirements of enterprise and the implementation BI strategy. A good report can reflect enterprise's current operation status and give support to strategic decisions for the future. This paper gives the definition of multidimensional dynamic reports. The method of configuring report information by using XML and realizing the statistics of multidimensional dynamic reports by high-level programming language are also in this paper.

Containers, monads and induction recursion

2014 ◽  
Vol 26 (1) ◽  
pp. 89-113 ◽  
Author(s):  
NEIL GHANI ◽  
PETER HANCOCK
Keyword(s):  
Programming Language ◽  
Algebraic Structure ◽  
Functional Programming ◽  
Type System ◽  
Pivotal Role ◽  
A Value ◽  
Structural Recursion ◽  
Definition Of ◽  
High Level ◽  
Original Type

Induction recursion offers the possibility of a clean, simple and yet powerful meta-language for the type system of a dependently typed programming language. At its crux, induction recursion allows us to define a universe, that is a setUofcodesand a decoding functionT : U → Dwhich assigns to every codeu : U, a valueT, uof some typeD, e.g.the large type Set of small types or sets. The name induction recursion refers to the build-up of codes inUusing inductive clauses, simultaneously with the definition of the functionT, by structural recursion on codes.Our contribution is to (i) bring out explicitly algebraic structure which is less visible in the original type-theoretic presentation – in particular showing how containers and monads play a pivotal role within induction recursion; and (ii) use these structures to present a clean and high level definition of induction recursion suitable for use in functional programming.

scholarly journals Component J: A component-based programming language with dynamic reconfiguration

2008 ◽  
Vol 5 (2) ◽  
pp. 63-86 ◽  
Author(s):  
João Seco ◽  
Ricardo Silva ◽  
Margarida Piriquito
Keyword(s):  
Structural Properties ◽  
Programming Language ◽  
Type System ◽  
Dynamic Reconfiguration ◽  
Language Design ◽  
Core Component ◽  
Language Level ◽  
Definition Of ◽  
High Level ◽  
Composition Operations

This paper describes an evolution of the ComponentJ programming language, a component-based Java-like programming language where composition is the chosen structuring mechanism. ComponentJ constructs allow for the high-level specification of component structures, which are the basis for the definition of compound objects. In this paper we present a new language design for ComponentJ which is more flexible and also allows the dynamic reconfiguration of objects. The manipulation of components and composition operations at the programming language level allows for the compile time verification, by a type system, of safety structural properties of ComponentJ programs. This work is based on earlier fundamental results where the main concepts are presented and justified in the form of a core component calculus. .

Sign in / Sign up

Export Citation Format

Share Document