Category Archives: Types

Type safety, Validation and verification

Labeled Data: Records and Variants

Records and variants are basic labeled data types. A record might be expressed as `{x:12.1, y:13.7}`, having a value for each label. A variant might be `Damage:11.3` or `Say:”Hello”`, and involves selection of one label and an associated value. We … Continue reading

Posted in Language Design, Types | Tagged , , , , , , | Leave a comment

Embedded Literal Objects

When a PL is designed for a text editor, it is natural that text is the richest embedded literal. The text editor provides the visualization and update HCI. And text can certainly be useful; beyond modeling a subset of human … Continue reading

Posted in Language Design, Modularity, Types, User Interface, UserInterface | 5 Comments

Substructural Types in ABC

Awelon Bytecode (ABC) has two operators, `k` and `f`, to support modeling of substructural constraints. In ABC, `k` will mark a block no-drop (relevant), and `f` will mark it no-copy (affine). If both marks are applied, the block is effectively … Continue reading

Posted in Language Design, Types | 1 Comment

UI as an Act of Programming

I’ve been thinking quite a bit, recently, about the relationship between UI and programming. A programming language is certainly a user interface – but usually a poor one from a human factors standpoint. And a UI can be considered a … Continue reading

Posted in Language Design, Types, User Interface, UserInterface | 15 Comments

Staging is Simpler than Type Checking

I’m taking an unusual approach to types with Awelon, one that I hope will work better than traditional approaches. Instead of “type checking”, every Awelon program represents a compile-time program. If this compile-time program completes without errors, then the runtime … Continue reading

Posted in Language Design, Types | 5 Comments

Awelon Virtual Machine

An ‘Awelon Virtual Machine’ (AVM) is a description of an RDP-based programming environment. This description includes types, partitions, and behavior primitives. It is a complete description, repeating even the ‘standard’ primitives like first and compose. Unlike a traditional VM, an … Continue reading

Posted in Grammars, Language Design, Modularity, Reactive Demand Programming, Types | Leave a comment

Multi Stack Environment in Awelon

Last post, I took things to an extreme. Which is a good thing. Extremism tells us where the limits are. After we know the limits, we can seek balance. There is a simple problem with the tree-zipper environment: It is … Continue reading

Posted in Concurrency, Language Design, Modularity, Types, UserInterface | 3 Comments

Ad-Hoc External State Models

Encapsulation, Accessibility, Security One of the main reasons we encapsulate state is to gain more control over how it updates. For example, take your traditional, imperative, mutable state variables that respond to get and put actions. We might use one … Continue reading

Posted in Concurrency, Language Design, Modularity, Open Systems Programming, Reactive Demand Programming, State, Types | 1 Comment

Stone Soup Programming

Stone soup programming is meant to evoke an image of throwing software components into a pot – in no particular order, and paying little attention to the ingredients – and the result being a nice application. The glue code between … Continue reading

Posted in Language Design, Live Programming, Modularity, Reactive Demand Programming, Stability, Types | 7 Comments

Exponential Decay of History

There are many problems for which it is useful to keep a history. A few examples of such problems: keep history of control-flow in an application for debugging purposes keep history of updates to a document for undo purposes keep … Continue reading

Posted in Language Design, Stability, State, Types, User Interface | 5 Comments