scholarly journals Towards imperative modules: Reasoning about invariants and sharing of mutable state

2006 ◽  
Vol 365 (1-2) ◽  
pp. 143-168 ◽  
Author(s):  
David A. Naumann ◽  
Mike Barnett
Keyword(s):  
Mutable State

On the roles of repetition in language teaching and learning

2012 ◽  
Vol 3 (2) ◽  
pp. 195-210 ◽  
Author(s):  
Diane Larsen-Freeman,
Keyword(s):  
Language Learning ◽  
Complexity Theory ◽  
Teaching And Learning ◽  
Language Use ◽  
Language Teaching ◽  
The World ◽  
Mutable State ◽  
Exact Replication ◽  
Language Teaching And Learning

AbstractRepetition is common in language use. Similarly, having students repeat is a common practice in language teaching. After surveying some of the better known contributions of repetition to language learning, I propose an innovative role for repetition from the perspective of complexity theory. I argue that we should not think of repetition as exact replication, but rather we should think of it as iteration that generates variation. Thus, what results from iteration is a mutable state. Iteration is one way that we create options in how to make meaning, position ourselves in the world as we want, understand the differences which we encounter in others, and adapt to a changing context.

scholarly journals A concurrent constraint programming interpretation of access permissions

2018 ◽  
Vol 18 (2) ◽  
pp. 252-295
Author(s):  
CARLOS OLARTE ◽  
ELAINE PIMENTEL ◽  
CAMILO RUEDA
Keyword(s):  
Programming Languages ◽  
Linear Logic ◽  
Object Oriented Programming ◽  
Theorem Prover ◽  
Deadlock Detection ◽  
Program Correctness ◽  
Detection Program ◽  
Mutable State ◽  
Verification Techniques ◽  
Access Permissions

AbstractA recent trend in object-oriented programming languages is the use of access permissions (APs) as an abstraction for controlling concurrent executions of programs. The use of AP source code annotations defines a protocol specifying how object references can access the mutable state of objects. Although the use of APs simplifies the task of writing concurrent code, an unsystematic use of them can lead to subtle problems. This paper presents a declarative interpretation of APs as linear concurrent constraint programs (lcc). We represent APs as constraints (i.e., formulas in logic) in an underlying constraint system whose entailment relation models the transformation rules of APs. Moreover, we use processes inlccto model the dependencies imposed by APs, thus allowing the faithful representation of their flow in the program. We verify relevant properties about AP programs by taking advantage of the interpretation oflccprocesses as formulas in Girard's intuitionistic linear logic (ILL). Properties include deadlock detection, program correctness (whether programs adhere to their AP specifications or not), and the ability of methods to run concurrently. By relying on a focusing discipline for ILL, we provide a complexity measure for proofs of the above-mentioned properties. The effectiveness of our verification techniques is demonstrated by implementing the Alcove tool that includes an animator and a verifier. The former executes thelccmodel, observing the flow of APs, and quickly finding inconsistencies of the APs vis-à-vis the implementation. The latter is an automatic theorem prover based on ILL.

scholarly journals A monadic analysis of information flow security with mutable state

2005 ◽  
Vol 15 (2) ◽  
pp. 249-291 ◽  
Author(s):  
KARL CRARY ◽  
ALEKSEY KLIGER ◽  
FRANK PFENNING
Keyword(s):  
Side Effects ◽  
Information Flow ◽  
Operational Semantics ◽  
Higher Order ◽  
Information Flow Security ◽  
Low Level ◽  
High Security ◽  
Mutable State ◽  
Security Levels ◽  
Typed Languages

We explore the logical underpinnings of higher-order, security-typed languages with mutable state. Our analysis is based on a logic of information flow derived from lax logic and the monadic metalanguage. Thus, our logic deals with mutation explicitly, with impurity reflected in the types, in contrast to most higher-order security-typed languages, which deal with mutation implicitly via side-effects. More importantly, we also take a store-oriented view of security, wherein security levels are associated with elements of the mutable store. This view matches closely with the operational semantics of low-level imperative languages where information flow is expressed by operations on the store. An interesting feature of our analysis lies in its treatment of upcalls (low-security computations that include high-security ones), employing an “informativeness” judgment indicating under what circumstances a type carries useful information.

scholarly journals Propositions-as-types and shared state

2021 ◽  
Vol 5 (ICFP) ◽  
pp. 1-30
Author(s):  
Pedro Rocha ◽  
Luís Caires
Keyword(s):  
Programming Languages ◽  
Programming Language ◽  
Linear Logic ◽  
Natural Extension ◽  
Concurrent Programming ◽  
Type Systems ◽  
Liveness Properties ◽  
Mutable State ◽  
Shared State ◽  
Logical Rules

We develop a principled integration of shared mutable state into a proposition-as-types linear logic interpretation of a session-based concurrent programming language. While the foundation of type systems for the functional core of programming languages often builds on the proposition-as-types correspondence, automatically ensuring strong safety and liveness properties, imperative features have mostly been handled by extra-logical constructions. Our system crucially builds on the integration of nondeterminism and sharing, inspired by logical rules of differential linear logic, and ensures session fidelity, progress, confluence and normalisation, while being able to handle first-class shareable reference cells storing any persistent object. We also show how preservation and, perhaps surprisingly, progress, resiliently survive in a natural extension of our language with first-class locks. We illustrate the expressiveness of our language with examples highlighting detailed features, up to simple shareable concurrent ADTs.

scholarly journals Profiling Initialisation Behaviour in Java

2021 ◽  
Author(s):  
◽  
Stephen Frank Nelson
Keyword(s):  
Programming Languages ◽  
Program Analysis ◽  
Garbage Collection ◽  
Hybrid Approach ◽  
Memory Consumption ◽  
Aspect Oriented Programming ◽  
Analysis Study ◽  
Programming Tools ◽  
Mutable State ◽  
Blank Slate

<p>Freshly created objects are a blank slate: their mutable state and their constant properties must be initialised before they can be used. Programming languages like Java typically support object initialisation by providing constructor methods. This thesis examines the actual initialisation of objects in real-world programs to determine whether constructor methods support the initialisation that programmers actually perform. Determining which object initialisation techniques are most popular and how they can be identified will allow language designers to better understand the needs of programmers, and give insights that VM designers could use to optimise the performance of language implementations, reduce memory consumption, and improve garbage collection behaviour. Traditional profiling typically either focuses on timing, or uses sampling or heap snapshots to approximate whole program analysis. Classifying the behaviour of objects throughout their lifetime requires analysis of all program behaviour without approximation. This thesis presents two novel whole-program object profilers: one using purely class modification (#prof ), and a hybrid approach utilising class modification and JVM support (rprof ). #prof modifies programs using aspect-oriented programming tools to generate and aggregate data and examines objects that enter different collections to determine whether correlation exists between initialisation behaviour and the use of equality operators and collections. rprof confirms the results of an existing static analysis study of field initialisation using runtime analysis, and provides a novel study of object initialisation behaviour patterns.</p>

scholarly journals Interprocedural Control Flow Analysis (Extended version)

1998 ◽  
Vol 27 (538) ◽  
Author(s):  
Flemming Nielson ◽  
Hanne Riis Nielson
Keyword(s):  
Abstract Interpretation ◽  
Data Flow ◽  
Flow Analysis ◽  
Object Oriented ◽  
Control Flow ◽  
Data Flow Analysis ◽  
Context Sensitive ◽  
Mutable State ◽  
Do So ◽  
Control Flow Analysis

Control Flow Analysis is a widely used approach for analysing functional and object oriented programs and recently it has also successfully been used to analyse more challenging notions of computation involving concurrency. However, once the applications become more demanding also the analysis needs to be more precise in its ability to deal with mutable state (or side-effects) and to perform polyvariant (or context-sensitive) analysis. Several insights in Data Flow Analysis and Abstract Interpretation show how to do so for imperative programs but the techniques have not had much impact on Control Flow Analysis because of the less abstract way in which the techniques are normally expressed. In this paper we show how to incorporate a number of key insights from Data Flow Analysis involving such advanced interprocedural techniques as call strings and assumption sets using Abstract Interpretation to induce the analyses from a general collecting semantics.

scholarly journals Profiling Initialisation Behaviour in Java

2021 ◽  
Author(s):  
◽  
Stephen Frank Nelson
Keyword(s):  
Programming Languages ◽  
Program Analysis ◽  
Garbage Collection ◽  
Hybrid Approach ◽  
Memory Consumption ◽  
Aspect Oriented Programming ◽  
Analysis Study ◽  
Programming Tools ◽  
Mutable State ◽  
Blank Slate

<p>Freshly created objects are a blank slate: their mutable state and their constant properties must be initialised before they can be used. Programming languages like Java typically support object initialisation by providing constructor methods. This thesis examines the actual initialisation of objects in real-world programs to determine whether constructor methods support the initialisation that programmers actually perform. Determining which object initialisation techniques are most popular and how they can be identified will allow language designers to better understand the needs of programmers, and give insights that VM designers could use to optimise the performance of language implementations, reduce memory consumption, and improve garbage collection behaviour. Traditional profiling typically either focuses on timing, or uses sampling or heap snapshots to approximate whole program analysis. Classifying the behaviour of objects throughout their lifetime requires analysis of all program behaviour without approximation. This thesis presents two novel whole-program object profilers: one using purely class modification (#prof ), and a hybrid approach utilising class modification and JVM support (rprof ). #prof modifies programs using aspect-oriented programming tools to generate and aggregate data and examines objects that enter different collections to determine whether correlation exists between initialisation behaviour and the use of equality operators and collections. rprof confirms the results of an existing static analysis study of field initialisation using runtime analysis, and provides a novel study of object initialisation behaviour patterns.</p>

scholarly journals Adjoint Reactive GUI Programming

2021 ◽  
pp. 289-309
Author(s):  
Christian Uldal Graulund ◽  
Dmitrij Szamozvancev ◽  
Neel Krishnaswami
Keyword(s):  
User Interfaces ◽  
Building Block ◽  
Implementation Strategy ◽  
Efficient Implementation ◽  
Graphical User Interfaces ◽  
Logical Interpretation ◽  
Functional Reactive Programming ◽  
Mutable State ◽  
Reactive Programming ◽  
Program Cycle

AbstractMost interaction with a computer is via graphical user interfaces. These are traditionally implemented imperatively, using shared mutable state and callbacks. This is efficient, but is also difficult to reason about and error prone. Functional Reactive Programming (FRP) provides an elegant alternative which allows GUIs to be designed in a declarative fashion. However, most FRP languages are synchronous and continually check for new data. This means that an FRP-style GUI will “wake up” on each program cycle. This is problematic for applications like text editors and browsers, where often nothing happens for extended periods of time, and we want the implementation to sleep until new data arrives. In this paper, we present an asynchronous FRP language for designing GUIs called $$\lambda _{\mathsf {Widget}}$$ λ Widget . Our language provides a novel semantics for widgets, the building block of GUIs, which offers both a natural Curry–Howard logical interpretation and an efficient implementation strategy.

scholarly journals Reasoning about effect interaction by fusion

2021 ◽  
Vol 5 (ICFP) ◽  
pp. 1-29
Author(s):  
Zhixuan Yang ◽  
Nicolas Wu
Keyword(s):  
Case Studies ◽  
Sufficient Conditions ◽  
Correct Order ◽  
Syntax Tree ◽  
Mutable State

Effect handlers can be composed by applying them sequentially, each handling some operations and leaving other operations uninterpreted in the syntax tree. However, the semantics of composed handlers can be subtle---it is well known that different orders of composing handlers can lead to drastically different semantics. Determining the correct order of composition is a non-trivial task. To alleviate this problem, this paper presents a systematic way of deriving sufficient conditions on handlers for their composite to correctly handle combinations, such as the sum and the tensor, of the effect theories separately handled. These conditions are solely characterised by the clauses for relevant operations of the handlers, and are derived by fusing two handlers into one using a form of fold/build fusion and continuation-passing style transformation. As case studies, the technique is applied to commutative and distributive interaction of handlers to obtain a series of results about the interaction of common handlers: (a) equations respected by each handler are preserved after handler composition; (b) handling mutable state before any handler gives rise to a semantics in which state operations are commutative with any operations from the latter handler; (c) handling the writer effect and mutable state in either order gives rise to a correct handler of the commutative combination of these two theories.

Sign in / Sign up

Export Citation Format

Share Document