Concrete syntax for objects

Context: Reactive programming (RP) is a declarative programming paradigm suitable for expressing the handling of events. It enables programmers to create applications that react automatically to changes over time. Whenever a time-varying signal changes -- e.g. in response to values produced by event stream (e.g., sensor data, user input...) -- the program state is updated automatically in tandem with that change. This makes RP well-suited for building interactive applications and reactive (soft real-time) systems. Inquiry: RP Language implementations are often built on top of an existing (host) language as an Embedded Domain Specific Language (EDSL). This results in application code in which reactive code and non-reactive code is inherently entangled. Using a mechanism known as lifting, one usually has access to the full feature set of the (non-reactive) host language in the RP program. However, lifting is also dangerous. First, host code expressed in a Turing-complete language may diverge, resulting in unresponsive programs: i.e. reactive programs that are not actually reactive. Second, the bi-directional integration of reactive and non-reactive code results in a paradigmatic mismatch that, when unchecked, leads to faulty behaviour in programs. Approach: We propose a new reactive programming language, that has been meticulously designed to be reactive-only. We start with a simple (first-order) model for reactivity, based on reactors (i.e. uninstantiated descriptions of signals and their dependencies) and deployments (i.e. instances of reactors) that consist of signals. The language does not have the notion of functions, and thus unlike other RP languages there is no lifting either. We extend this simple model incrementally with additional features found in other programming languages, RP or otherwise. These features include stateful reactors (that allow for time-based accumulation), signals with dynamic dependencies by means of conditionals and polymorphic deployments, recursively-defined reactors, and (anonymous) reactors with lexical scope. Knowledge: In our description of these language features, we not only describe the syntax and semantics, but also how each features compares to the problems that exist in (EDSL) RP languages. I.e. by starting from a reactive-only model, we identify which reactive features (that, in other RP languages are typically expressed in non-reactive code) affect the reactive guarantees that can be enforced by the language. Grounding: We base our arguments by analysing the effect that each feature has on our language: e.g., by analysing how signals are updated, how they are created and how dependencies between signals can be affected. When applicable, we draw parallels with other languages: i.e. similarities shared with other RP languages will be highlighted and thoroughly analysed, and where relevant the same will also be done with non-reactive languages. Importance: Our language shows how a purely reactive programming is able to express the same kinds of programs as in other RP languages that require the use of (unchecked) functions. By considering reactive programs as a collection of pure (reactive-only) reactors, we aim to increase how reactive programming is comprehended by both language designers and its users.

Concurrency has been with us almost from the beginning of computing. Managing and programming for concurrency is a difficult problem and various solutions have been suggested over the years. Debates on message passing vs. remote procedure call, synchronous vs. asynchronous message passing, bounded vs. unbounded buffers, active vs. passive objects etc. still continue. No solution is entirely satisfactory. Concurrent programming usually depends heavily on the nature of the problem at hand and the architecture of the target machine.

This Article discusses the impacts of the introduction of a data ownership scheme on access to information. It does so with reference to the distinction between data, defined as some representation of information by a specific medium (the syntactic level), and the information itself (the semantic level). With respect to data, it then looks at the difference between standard property rights and intellectual property (IP) rights, similarly assessing impacts on access to information. Private control at the semantic level is bad policy as it effects particularly serious limitations, relative to private control at the syntactic level, on the availability of information in society. IP-type rights similarly effect more serious limitations on the availability of information in society than do standard property rights over data. Focusing on the syntactic-semantic divide to discuss the data ownership case clarifies a few things. First, although there are reasons to be more solicitous of the case for data ownership for data subjects than the case for data ownership for others, there must be an acknowledgment of the fact that the former case often requires data ownership over the information itself. The two premier rationales for granting data ownership to data subjects are that such rights would enable data subjects to protect their privacy, and that it would enable them to claim a share in the benefits of the data economy. This Article points out that any effective attainment of these rationales for data ownership for data subjects requires that data subjects be empowered to exclude others from information even before its collection—that is, even before its representation in syntactic form. This is exclusion power over semantic information. Second, the data ownership for data subjects case is less objectionable in the context of control at the syntactic level as such control is less likely to lead to indirect semantic-level control. By contrast, control at the syntactic level by data collectors creates the problem of indirect semantic control. There is, therefore, no meaningful case for data ownership for data collectors, even at the syntactic level. But the reduced likelihood of indirect semantic-level control in the context of data subjects means that there are sometimes prospects for propertarian rights for data subjects over data being structured to avoid semantic control. What emerges from this understanding is a pattern in which policy supports some syntactic bases for a propertarian remedy for data subjects, but otherwise counsels against data ownership. Finally, those bases for a propertarian remedy over data for data subjects are limited to discrete areas where data ownership for data subjects can be deployed with little, or no, control being exerted at the semantic level, and therefore at little to no cost in public access to information. This is likely to be especially true in the context of standard property as semantic-level control by data subjects is more likely to be a non-issue in this case.

This paper reports some misconceptions that are frequently detected in students of introductory compiler construction courses. Compiler construction is a topic included in many university computer science programs. It deals with the design and implementation of programming and other computer languages. These misconceptions have been identified by the author when teaching the topic at the Complutense University of Madrid (Spain). The misconceptions are classified according to the different stages approached in compiler construction: lexical level, syntactic level, semantic level. At the lexical level the following misconceptions are documented: (i) incorrect identification of token types; (ii) transitions with more than one symbol in the state transition diagrams; and (iii) inadequate treatment of keywords. Misconceptions at the syntactic level include: (i) confusing non-determinism and ambiguity; (ii) considering ε (the empty string) as a terminal symbol; (iii) misinterpreting operator precedence; (iv) attempting to perform type checking at the syntactic level; and (v) grammar transformation errors. Finally, the following misconceptions are reported at the semantic level: (i) transformations that do not preserve semantics; (ii) difficulties in determining the abstract syntax trees of complex sentences; (iii) incorrect interpretation of how the symbol table works during the analysis of lexically-scoped languages; (iv) variable addressing errors; and (v) errors related to the translation of complex designators. Identifying these errors is very useful in developing instructional strategies to help students avoid them.

We've embraced the Growing a Language philosophy (Guy Steele, OOPSLA'98): Languages expose a small core while libraries add the domain-specific tasks, manage communication and scale computation to thousands of machines in a reliable fashion. It's both amazing and scary to see what can be achieved with a small core language and a liberal syntax: we're at a point where programmers use domain-specific languages without even realizing it, thanks to the perfect host language integration. Yet, there is a conflict in this approach: Although libraries open up domain-specific optimization opportunities, such as fusion, we don't have the means to exploit that. Being implemented in terms of the core language, both libraries and client programs are all compiled down to low-level intermediate representations, where even the smartest optimizers can't recover the high-level optimization opportunities. There's a fundamental mismatch - despite their good integration with the host language, domain-specific libraries simply don't have good optimization mechanisms. We are sorely missing a mechanism for library self-optimization, and even more, inter-library optimization. Unfortunately, the existing approaches, such as macros, multi-stage programming and partially evaluated interpreters (like Truffle) are difficult to use for mainstream programmers and make it almost impossible to express optimizations across different libraries. Missing this cross-library composition means each optimization has to make pessimistic assumptions about the code outside its control, reducing the number of possible optimizations for a library taken alone. For example, there's little one can do to to optimize an off-heap array in general, but if we know it stores pairs of integers and sparse matrices, there's suddenly an opportunity to reorganize the data and to make access more efficient. Therefore the most benefit can be gained from inter-library optimizations. In this presentation, I show my work on programmer-driven domain-specific transformations, which can work across different libraries. This approach can express high-level transformations in the host language in a very natural and self-contained way, making them amenable to distribution along with libraries or as separate artifacts. In turn, this allows the library users to mix and match both the libraries and transformations they need for the task at hand. Furthermore, the transformation is expressed based on the conversion methods, which allow triggering the transformation for both generic (e.g. for all vectors, regardless of the element type) and specific targets (e.g. only vectors of pairs of numeric types) -- the full type system expressivity is available to select the transformation target and to specify the transformation result. On the compiler side, the work focuses on correctly transforming programs, assuming an open-world and allowing object-oriented dynamic dispatch and overriding. There are many considerations to take into account. For example, when overriding methods change signatures due to the transformation, bridges need to be created in order to preserve the object model. The Scala implementation, made as a compiler plugin, relies on a strong type-flow-based data representation transformation mechanism (Late Data Layout) that currently powers specialization (through miniboxing), value class transformations and compiler support for multi-stage programming. The project implementation is open-source at https://github.com/miniboxing/ildl-plugin and the paper is available at https://infoscience.epfl.ch/record/207050. You can also read about the sample transformations, such as deforestation, array of struct to struct of array and localized optimistic specialization on the project wiki: https://github.com/miniboxing/ildl-plugin/wiki.

A number of concurrent computers have been designed, such as [Ametek 1988] and [NCUBE 1986]. Taking advantage of concurrency on these computers will require new languages, operating systems, and environments to support the programming, monitoring and control of applications. The Rosette project at MCC is developing a system architecture for general-purpose concurrent computation based on the Actor model [Agha 1986]. The aim of the Rosette architecture is to support the use of concurrent computers in solving computationally intensive problems whose structure is not statically determined. The architecture will support variable grain size, dynamic resource management, reflection, and heterogeneity. A number of concurrent language proposals have employed computational models that are limited in their applicability because of assumptions such as granularity of concurrency, static process topology, or inherent communications cost. Others, for example, functional programming, cannot be used to model shared, modifiable objects. The Actor model addresses these issues directly. However, the difficulties of using concurrent computers cannot be addressed solely through programming languages. Traditional operating systems treat each process as an independent entity for the purposes of resource management (i.e., for the run-time allocation of processor, storage, and communication resources.) In the context of concurrent applications, effective operation on a concurrent computer requires that communities of processes be managed together, taking into account the ways in which they interact, and providing for the application itself to guide resource management. For example, consider that programming systems often provide only limited support for the control of resource consumption in search problems in the face of combinatorial explosion; further, it is generally recognized that to optimize search performance, it is useful to vary the resources provided depending on how promising intermediate results of a given path are judged to be. The Rosette architecture will allow the programmer to integrate high-level algorithms within the application for dividing resources dynamically among the sub-computations that are spawned. These algorithms will provide an assessment of the progress of the sub-computations, and will be used to make the large number of low-level resource management decisions that are necessary in carrying out the computation. Thus, operating system functionality will be folded into the application. The Rosette architecture has two major components: an interface layer and a system environment . The interface layer provides mechanisms for the monitoring and control of concurrent applications. It supports a uniform view of the system resources and applications through the use of actors and message-passing semantics. The interface layer includes a set of actors that represent the processing, storage and communication resources across the hardware base. The system environment contains actor communities which implement resource management policies , and support for programming concurrent applications. The environment consists of an extensible set of actors that are organized via a class-based object model. These actors provide monitoring, debugging, resource management system simulation, and compilation/transformation facilities. To demonstrate the effectiveness of the Rosette architecture, as well as to drive its development, two classes of applications are being used. The first class is the Rosette system itself: all of the system components necessary for resource management, monitoring, debugging, and program development are being constructed in the Rosette language and will take full advantage of both concurrency and object-oriented programming support. The second category of applications is chosen to be somewhat independent of the Rosette system so as to ensure adequate feed-back concerning applicability to domains other than software engineering. These applications are in the general area of knowledge-based signal interpretation. The Rosette architecture is implemented via a concurrent object-oriented programming language that provides the following features: Inherent concurrency : A declarative approach is needed which allows fine-grained concurrency to arise naturally from the program. If the programmer is forced to express all of the details of the concurrent execution of an application, it becomes difficult to re-map a given program to different concurrent computers which have varying concurrency characteristics. Dynamic creation/modification of objects : This allows the system to be extensible and reconfigurable. Sharing : The language should support mechanisms such as inheritance so that code, structure, and values need not be replicated. Classes : Objects can be organized into classes to permit more effective management of resources, as for example in a very large database. Classes should be first-class objects and hence it should be possible to create classes dynamically. The Rosette language is a high-level language that is translated into a base language that directly expresses concurrent computations in terms of the semantics of the Actor model. The Rosette language extends the base language with data abstraction facilities and a library of classes, and is used to implement the non-built-in actors of the interface layer, components of the system environment, and applications. Using data abstraction extensions to the base language, the Rosette language organizes actors into classes according to common sets of behaviors and local state. Inheritance is used as a means of sharing code and structure that is common among classes. There is considerable evidence, for example [LaLonde 1986] and [Snyder 1987], that a robust class system should support separate hierarchies that represent what is modeled by a class and how some class of objects are actually implemented. Our approach is to use three different kinds of classes to organize the various kinds of actors in a system and information about these actors: abstract classes specify observable requests, responses, and actions; representation classes specify resource management characteristics of implementations; and behavior classes contain the actual implementations. Associated with an abstract class is the set of representations that are available to implement the particular abstraction. Each representation is associated with the behavior class that contains the corresponding implementation. The power of this separation is that each of the three kinds of class may be related to others in a class hierarchy. This means that the relationships between abstract classes are not forced to have the same structure as the relationships among implementations. Sharing via inheritance among behavior classes is related to engineering concerns; relations among abstract classes are dictated by external/observable behavior. As an example, an abstract class might specify the operations available over real-matrices . There are several ways of representing a matrix as a community of actors, and each of these would be specified with appropriate representation and behavior classes. There is a well-defined abstract hierarchy of matrices such as invertible, positive , etc. These abstract kinds of matrices are independent of the various implementations, which may be chosen according to application and hardware resource constraints. The Rosette language embodies a reflective model of the interface layer that is similar to that used in ABCL/R, [Watanabe and Yonezawa 1988]. This model is t

This paper extends our method to construct a shallow embedded domain specific language, DSL, embedded in a function programming language. We show how one can add functions and tasks that are typed by the type system of the functional host language. The DSL is clearly separated from its host functional language to facilitate the compilation to small executables in C++. The type system of the host language verifies the types in the DSL, including the types and proper use of variables. The DSL is extendable by new language constructs and interpretations without breaking any existing code. The type system guarantees that everything used in a DSL program is properly defined. We apply these techniques for a DSL to program Arduino microprocessor systems from Clean. The long term goal is to incorporate these microprocessors in the iTask system.

Domain-specific languages (DSLs) are increasingly used as embedded languages within general-purpose host languages. DSLs provide a compact, dedicated syntax for specifying parts of an application related to specialized domains. Unfortunately, such language extensions typically do not integrate well with the development tools of the host language. Editors, compilers and debuggers are either unaware of the extensions, or must be adapted at a non-trivial cost. We present a novel approach to embed DSLs into an existing host language by leveraging the underlying representation of the host language used by these tools. Helvetia is an extensible system that intercepts the compilation pipeline of the Smalltalk host language to seamlessly integrate language extensions. We validate our approach by case studies that demonstrate three fundamentally different ways to extend or adapt the host language syntax and semantics.KeywordsParse TreeTransactional MemoryLanguage ExtensionAbstract Syntax TreeSoftware Transactional MemoryThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

A program is composed of commands that run within a computer or an electronic circuit. Programming is a mathematical methodology to write a program and to encode the algorithm into a notation. It can be classified into two groups such as system and application programming. System programming is a branch of the general programming that is composed of low-level instructions which are used to operate and handle computer hardware. Application programming is considered as the improved version of the computer programs that can perform specific tasks. One of the application programming types is the object-oriented programming (OOP) which is about how information is represented in human mind. OOP is useful to provide easy modeling in design and developing real entities. This approach is aimed to model the entities and the relationships existing between them. OOP enables to define the required classes to create the objects and to apply modifications on them. The inherent properties of OOP are modularity, extensibility, and reusability. This chapter provides a substantial survey of OOP.

A framework for compiler construction of functional programming languages is described. The framework has been designed to allow experimenting with functional programming languages and their implementations. Its three main characteristics are: (1) given the existing implementation of a functional programming language (not necessary in a source code), the implementation of a new functional programming language can be easily and efficiently developed, using the framework; (2) the framework enables enhancement of already implemented languages with new features; and (3) implementations of the languages in the framework are transparent, which can be freely exchanged between the languages.

Inheritance is a powerful concept employed in computer science, especially in artificial intelligence (AI), object-oriented programming (OOP), and object-oriented databases (OODB). In the field of AI, inheritance has been primarily used as a concise and effective means of representing and reasoning with common-sense knowledge (Thirunarayan, 1995). In programming languages and databases, inheritance has been used for the purpose of sharing data and methods, and for enabling modularity of software (re)use and maintenance (Lakshmanan & Thirunarayan, 1998). In this chapter, we present various design choices for incorporating inheritance into programming languages from an application programmer’s perspective. In contrast with the language of mathematics, which is mature and well-understood, the embodiment of object-oriented concepts and constructs in a concrete programming language is neither fixed nor universally accepted. We exhibit programs with similar syntax in different languages that have very different semantics, and different looking programs that are equivalent. We compare and contrast method inheritance, interaction of type system with method binding, constructs for method redefinition, and their implementation in widely used languages such as C++ (Stroustrup, 1997), Java (Arnold, Gosling, & Holmes, 2005), and C# (Hejlsberg, Wiltamuth, & Golde, 2006), to illustrate subtle issues of interest to programmers. Finally, we discuss multiple inheritance briefly.

This paper gives an introduction to concepts for a better expert knowledge extraction for geodata harmonisation. Geodata harmonisation involves overcoming heterogeneities on the syntactic, schematic and se-mantic levels, but user interaction is mostly required for the semantic interoperability level. Consequently, the goal is to provide tools to geo-domain experts which allow them to use their knowledge to describe the conceptual schemas of their domain as well as alignments to other domain's conceptual schemas in a sufficiently expressive way without be-coming experts in ontology engineering. We describe an approach for this that includes both visual analysis on the basis of geospatial instances and specific interaction guidance processes. Based on this approach, a prototypical implementation of a tool called the HUMBOLDT Alignment Editor (HALE) is introduced.

We define sentence generalization and generalization diagrams as a special sort of conceptual graphs which can be constructed automatically from syntactic parse trees and support semantic classification task. Similarity measure between syntactic parse trees is developed as a generalization operation on the lists of sub-trees of these trees. The diagrams are representation of mapping between the syntactic generalization level and semantic generalization level (anti-unification of logic forms). Generalization diagrams are intended to be more accurate semantic representation than conventional conceptual graphs for individual sentences because only syntactic commonalities are represented at semantic level.

Embedded Domain-Specific Languages (EDSLs) are an alternative to quickly implement specialized languages without the need to write compilers or interpreters from scratch. In this territory, Haskell is a prime choice as the host language. EDSLs in Haskell, however, are often incapable of reifying useful static information from the source code, namely variable binding names and source locations. Not having access to variable names directly affects EDSLs designed to generate low-level code, where the variables names in the generated code do not match those found in the source code—thus broadening the semantic gap among source and target code. Similarly, many existing EDSLs produce poor error messages due to the lack of knowledge of source locations where errors are generated.

One of the main advantages of an EDSL (embedded domain-specific language) is that new abstractions can be coded quickly and easily in the EDSL's host language and are automatically transformed to the basic EDSL primitives. In the context of formal software certification, it is paramount that evidence for the correctness of these abstractions are provided and that the low-level code resulting from the EDSL primitives can be traced to some higher-level artifacts, i.e. some concrete programming abstractions, software requirements etc. We have built an EDSL-based tool-chain for implementing and testing mission critical applications which supports measures to guarantee traceability and provides evidence of correctness of EDSL abstractions. We give an overview of our EDSL approach and practical experiences applying them in the industrial context.