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

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

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 Implementing type theory in higher order constraint logic programming

2019 ◽  
Vol 29 (8) ◽  
pp. 1125-1150
Author(s):  
FERRUCCIO GUIDI ◽  
CLAUDIO SACERDOTI COEN ◽  
ENRICO TASSI
Keyword(s):  
Programming Languages ◽  
Programming Language ◽  
Type System ◽  
Theorem Prover ◽  
Type Checking ◽  
Language Extension ◽  
Order Constraint ◽  
Simple Implementation ◽  
Calculus Of Inductive Constructions ◽  
High Level

In this paper, we are interested in high-level programming languages to implement the core components of an interactive theorem prover for a dependently typed language: the kernel – responsible for type-checking closed terms – and the elaborator – that manipulates open terms, that is terms containing unresolved unification variables.In this paper, we confirm that λProlog, the language developed by Miller and Nadathur since the 80s, is extremely suitable for implementing the kernel. Indeed, we easily obtain a type checker for the Calculus of Inductive Constructions (CIC). Even more, we do so in an incremental way by escalating a checker for a pure type system to the full CIC.We then turn our attention to the elaborator with the objective to obtain a simple implementation thanks to the features of the programming language. In particular, we want to use λProlog’s unification variables to model the object language ones. In this way, scope checking, carrying of assignments and occur checking are handled by the programming language.We observe that the eager generative semantics inherited from Prolog clashes with this plan. We propose an extension to λProlog that allows to control the generative semantics, suspend goals over flexible terms turning them into constraints, and finally manipulate these constraints at the meta-meta level via constraint handling rules.We implement the proposed language extension in the Embedded Lambda Prolog Interpreter system and we discuss how it can be used to extend the kernel into an elaborator for CIC.

A paradigmatic object-oriented programming language: Design, static typing and semantics

1994 ◽  
Vol 4 (2) ◽  
pp. 127-206 ◽  
Author(s):  
Kim B. Bruce
Keyword(s):  
Fixed Points ◽  
Programming Languages ◽  
Programming Language ◽  
Type System ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Language Design ◽  
Type Checking ◽  
Basic Features ◽  
Oriented Programming Language

AbstractTo illuminate the fundamental concepts involved in object-oriented programming languages, we describe the design of TOOPL, a paradigmatic, statically-typed, functional, object-oriented programming language which supports classes, objects, methods, hidden instance variables, subtypes and inheritance.It has proven to be quite difficult to design such a language which has a secure type system. A particular problem with statically type checking object-oriented languages is designing typechecking rules which ensure that methods provided in a superclass will continue to be type correct when inherited in a subclass. The type-checking rules for TOOPL have this feature, enabling library suppliers to provide only the interfaces of classes with actual executable code, while still allowing users to safely create subclasses. To achieve greater expressibility while retaining type-safety, we choose to separate the inheritance and subtyping hierarchy in the language.The design of TOOPL has been guided by an analysis of the semantics of the language, which is given in terms of a model of the F-bounded second-order lambda calculus with fixed points at both the element and type level. This semantics supports the language design by providing a means to prove that the type-checking rules are sound, thus guaranteeing that the language is type-safe.While the semantics of our language is rather complex, involving fixed points at both the element and type level, we believe that this reflects the inherent complexity of the basic features of object-oriented programming languages. Particularly complex features include the implicit recursion inherent in the use of the keyword, self, to refer to the current object, and its corresponding type, MyType. The notions of subclass and inheritance introduce the greatest semantic complexities, whereas the notion of subtype is more straightforward to deal with. Our semantic investigations lead us to recommend caution in the use of inheritance, since small changes to method definitions in subclasses can result in major changes to the meanings of the other methods of the class.

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.

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.

scholarly journals Just TYPEical: Visualizing Common Function Type Signatures in R

2020 ◽  
Author(s):  
Cameron Moy ◽  
Julia Belyakova ◽  
Alexi Turcotte ◽  
Sara Di Bartolomeo ◽  
Cody Dunne
Keyword(s):  
Programming Language ◽  
Type System ◽  
Language Design ◽  
Function Type ◽  
Programming Language Design ◽  
R Programming Language ◽  
Execution Traces ◽  
Rich Information ◽  
R Programming ◽  
Type Data

Data-driven approaches to programming language design are uncommon. Despite the availability of large code repositories, distilling semantically-rich information from programs remains difficult. Important dimensions, like run-time type data, are inscrutable without the appropriate tools. We contribute a task abstraction and interactive visualization, TYPEical, for programming language designers who are exploring and analyzing type information from execution traces. Our approach aids user understanding of function type signatures across many executions. Insights derived from our visualization are aimed at informing language design decisions — specifically of a new gradual type system being developed for the R programming language. A copy of this paper, along with all the supplemental material, is available at osf.io/mc6zt

scholarly journals Strong typing of object-oriented languages revisited

1990 ◽  
Vol 19 (326) ◽  
Author(s):  
Ole Lehrmann Madsen ◽  
Boris Magnusson ◽  
Birger Møller-Pedersen
Keyword(s):  
Programming Language ◽  
Type System ◽  
Object Oriented ◽  
Language Design ◽  
Type Checking ◽  
Programming Language Design ◽  
Dynamic Type ◽  
Language Construct ◽  
Object Oriented Languages

This paper is concerned with the relation between <em>subtyping</em> and <em>subclassing</em> and their influence on programming language design. Traditionally subclassing as introduced by Simula has also been used for defining a hierarchical type system. The type system of a language can be characterized as <em>strong</em> or <em> weak</em> and the type checking mechanism as <em>static</em> or <em>dynamic</em>. Parameterized classes in combination with a hierarchical type-system is an example of a language construct that is known to create complicated type checking situations. In this paper these situations are analyzed and several different solutions are found. It is argued that an approach with a combination of static and dynamic type checking gives a reasonable balance also here. It is also concluded that this approach makes it possible to base the type system on the class/subclass mechanism.

Sign in / Sign up

Export Citation Format

Share Document