LtU Forum

Going Against the Flow for Type-less Programming (take 3!)

This is a paper submission I'm working on for a conference deadline next week. This time is different, I've trimmed down my goals and have developed a system that really works! Anyways, abstract:

This paper introduces a Type-less type system that provides useful type feedback about OO code with "less" type annotations. Type-less rethinks type checking as a modular field-aware value flow analysis to allow inference on assignment with simplified variance and binding. Type-less also does type inference backwards to specializes term types based on their usage rather than generalizing types to validate their usage. Type annotations are then unnecessary in client code that does not define new abstractions, and greatly reduced otherwise. The result is a fluid programming experience whose feel approaches that of a dynamic language, which is demoed as part of this paper.

Short videos I've recorded of the system in use (I'll probably redo these next week, but they are still viewable):

Type theorists might hate my approach.

Who owns your research? Results of SIGPLAN Open Access survey

SIGPLAN is the ACM Special Interest Group (SIG) that focuses on Programming LANguages. It runs many of the field's academic conferences (ICFP, PLDI, POPL, SPLASH...) and its elected members are recognized researchers of the field (the chair and vice-chair are Jan Vitek and Jeremy Gibbons). It recently ran a survey on Open Access, questioning respondent's opinion on Open Access at large, Green vs Gold open-access, archival strategies, or indirectly-related questions such as "conferences vs. journals".

The results of the survey are summarized and present there: Who Owns Your Research: A Survey.

A harsh summary:

  • Everyone knows Open Access is the right way to publish research.
  • Seniors and Americans care about the ACM more than Juniors and Europeans.
  • Many people would "just use Arxiv" (but then, why are so few of our field's article made available on arxiv?)
  • Most do not care about Gold OA (where authors pay the publisher to make the article publicly available)
  • There is no consensus on "conferences versus journals"


What does everyone think about what our PL moonshots are or should be?

how many lines of code can civilization support?

Is there any programming language theory that considers absolute upper bounds on how many lines of code (or bytes or whatever) a civilization can actively maintain (as a function of population size)?

Are such upper bounds low enough that the limit should inform programming language design?

cicada-nymph -- a forth-like language for to teach

the little nymph is for teaching purpose only.

it reuses the code and idea
of the early version of cicada-language,

to teach my friends
how to implement a interpreter
of a simple programming language.

I will use assembly language (FASM for x86-64)
to implement the interpreter.

the programming language to be implemented
is a threaded-code based (Forth-like) language.

the following shows how to define "if" & "else" & "then" by "define-macro"

: if
  << string[address, length] --
     address, string[address, length] >>
  *false?branch* save-into,jo-heap
  *current-free-address,jo-heap* xx|swap|x
  0 save-into,jo-heap
; define-macro

: else
  << address, string[address, length] --
     address, string[address, length] >>
  *branch* save-into,jo-heap
  *current-free-address,jo-heap* xxx|swap|x
  0 save-into,jo-heap
  << address, string[address, length], address >>
  over sub *jo-size* div
  swap save
; define-macro

: then
  << address, string[address, length] --
     string[address, length] >>
  over sub *jo-size* div
  swap save
; define-macro

the following shows how to define factorial

: factorial
  << number -- number >>
  dup one? if
  dup sub1 factorial
; define-function

for the code and more info ::

code on github
view the code in a fake emacs org-mode

the main language I am designing is called cicada language
organization on github
[the design is not finished yet (2015 03 14)]

while the cicada nymph is a different language
and it is for teaching purpose only
thus many simplifications on features are made

the design of cicada language is influenced by scheme and forth and joy and smalltalk
I do not think, and will not say, which is "better" and "more powerful" than which
but some interesting features are to be designed for cicada language
I will post about them in the future ^-^

1ML — Core and modules united

This is an amazing paper that I've been anticipating ever since I read the abstract about half a year ago.

ML is two languages in one: there is the core, with types and expressions, and there are modules, with signatures, structures and functors. Modules form a separate, higher-order functional language on top of the core. There are both practical and technical reasons for this stratification; yet, it creates substantial duplication in syntax and semantics, and it reduces expressiveness. For example, selecting a module cannot be made a dynamic decision. Language extensions allowing modules to be packaged up as first-class values have been proposed and implemented in different variations. However, they remedy expressiveness only to some extent, are syntactically cumbersome, and do not alleviate redundancy.

We propose a redesign of ML in which modules are truly first-class values, and core and module layer are unified into one language. In this "1ML", functions, functors, and even type constructors are one and the same construct; likewise, no distinction is made between structures, records, or tuples. Or viewed the other way round, everything is just ("a mode of use of") modules. Yet, 1ML does not required dependent types, and its type structure is expressible in terms of plain System Fω, in a minor variation of our F-ing modules approach. We introduce both an explicitly typed version of 1ML, and an extension with Damas/Milner-style implicit quantification. Type inference for this language is not complete, but, we argue, not substantially worse than for Standard ML.

An alternative view is that 1ML is a user-friendly surface syntax for System Fω that allows combining term and type abstraction in a more compositional manner than the bare calculus.

Basically, it unifies module and core languages, without dependent types, while supporting type inference without requiring more type annotations than OCaml (i.e. only on module or higher-rank types). It leaves applicative functors for future work.

An extended technical report and a prototype interpreter are available here.

SPLASH 2015: 2nd Call for Contributions: OOPSLA, Onward!, Workshops, Dynamic Languages Symposium

ACM Conference on Systems, Programming, Languages, and Applications:
Software for Humanity (SPLASH'15)

Pittsburgh, Pennsylvania, USA
25th-30th October, 2015

Sponsored by ACM SIGPLAN

Dynamic Languages Symposium (DLS)

The ACM SIGPLAN conference on Systems, Programming, Languages and Applications: Software for Humanity (SPLASH) embraces all aspects of software construction and delivery to make it the premier conference at the intersection of programming, languages, and software engineering. SPLASH is now accepting submissions. We invite high quality submissions describing original and unpublished work.

** OOPSLA Research Papers **
Papers that address any aspect of software development are welcome, including requirements, modeling, prototyping, design, implementation, generation, analysis, verification, testing, evaluation, maintenance, reuse, replacement, and retirement of software systems. Papers may address these topics in a variety of ways, including new tools (such as languages, program analyses, and runtime systems), new techniques (such as methodologies, design processes, code organization approaches, and management techniques), and new evaluations (such as formalisms and proofs, corpora analyses, user studies, and surveys).

Submissions Due: 25 March, 2015

** Onward! Research Papers **
Onward! is a premier multidisciplinary conference focused on everything to do with programming and software: including processes, methods, languages, communities, and applications. Onward! is more radical, more visionary, and more open than other conferences to ideas that are well-argued but not yet proven. We welcome different ways of thinking about, approaching, and reporting on programming language and software engineering research.

Submissions Due: 2 April, 2015

** Onward! Essays **
Onward! Essays is looking for clear and compelling pieces of writing about topics important to the software community. An essay can be an exploration of a topic, its impact, or the circumstances of its creation; it can present a personal view of what is, explore a terrain, or lead the reader in an act of discovery; it can be a philosophical digression or a deep analysis. It can describe a personal journey, perhaps that by which the author reached an understanding of such a topic. The subject area should be interpreted broadly and can include the relationship of software to human endeavors, or its philosophical, sociological, psychological, historical, or anthropological underpinnings.

Submissions Due: 2 April, 2015

** Workshops **
The SPLASH Workshops track will host a variety of high-quality workshops, allowing their participants to meet and discuss research questions with peers, to mature new and exciting ideas, and to build up communities and start new collaborations. SPLASH workshops complement the main tracks of the conference and provide meetings in a smaller and more specialized setting. Workshops cultivate new ideas and concepts for the future, optionally recorded in formal proceedings.

Early Phase Submissions Due: 25 March, 2015
Late Phase Submissions Due: 30 June, 2015

** Dynamic Languages Symposium (DLS) **
DLS is the premier forum for researchers and practitioners to share knowledge and research on dynamic languages, their implementation, and applications. The influence of dynamic languages — from Lisp to Smalltalk to Python to Javascript — on real-world practice, and research, continues to grow. We invite high quality papers reporting original research, innovative contributions, or experience related to dynamic languages, their implementation, and applications.

Submissions Due: 7 June, 2015

** Co-Located Events **

8th International ACM SIGPLAN Conference on Software Language Engineering (SLE)
Submissions Due: 15 June, 2015

14th International Conference on Generative Programming: Concepts & Experiences (GPCE)
Submissions Due: 15 June, 2015

22nd International Conference on Pattern Languages of Programming (PLoP)
Submissions Due: 4 May, 2015

15th Symposium on Database Programming Languages (DBPL)
Submissions Due: 10 June, 2015

SPLASH Early Registration Deadline: 25 September, 2015

Sheraton Station Square Hotel
Pittsburgh, Pennsylvania, United States

SPLASH General Chair: Jonathan Aldrich (Carnegie Mellon University)
OOPSLA Papers Chair: Patrick Eugster (Purdue University)
Onward! Papers Chair: Gail Murphy (University of British Columbia)
Onward! Essays Chair: Guy Steele (Oracle Labs)
DLS Papers Chair: Manuel Serrano (INRIA)

Artifact Evaluation Co-Chairs: Robby Findler (Northwestern University) and Michael Hind (IBM Research)
Demos Co-Chairs: Igor Peshansky (Google) and Pietro Ferrara (IBM Research)
Inspirations Co-Chairs: Darya Kurilova (Carnegie Mellon University), Zach Tatlock (University of Washington), and Crista Lopes (UC Irvine)
Local Arrangements Chair: Claire Le Goues (Carnegie Mellon University)
Posters Chair: Nick Sumner (Simon Fraser University)
Publications Chair: Alex Potanin (Victoria University of Wellington)
Publicity and Web Co-Chairs: Craig Anslow (University of Calgary) and Tijs van der Storm (CWI)
SPLASH-E Chair: Eli Tilevich (Virginia Tech)
SPLASH-I Co-Chairs: Tijs van der Storm (CWI) and Jan Vitek (Northeastern University)
Sponsorship Chair: Tony Hosking (Purdue University)
Student Research Competition Co-Chairs: Sam Guyer (Tufts University) and Patrick Lam (University of Waterloo)
Student Volunteer Co-Chairs: Jonathan Bell (Columbia University) and Daco Harkes (TU Delft)
Wavefront Co-Chairs: Dennis Mancl (Alcatel-Lucent)
Web Technology Chair: Eelco Visser (TU Delft)
Workshops Co-Chairs: Du Li (Carnegie Mellon University) and Jan Rellermeyer (IBM Research)

SLE General Chair: Richard Paige (University of York)
GPCE General Chair: Christian Kästner (Carnegie Mellon University)
PLoP General Chair: Filipe Correia (University of Porto)
DBPL General Chairs: James Cheney (University of Edinburgh) and Thomas Neumann (TU Munich)

Constraint typing, subtyping, and separate compilation

Can someone help me decode this comment from this post on Scala type inference:

On the other extreme, it is *possible* to do constraint typing in a nominal type system with subtyping, but you have to give up entirely on separate compilation. Type checking effectively turns into a special case of control-flow analysis, which not only makes the whole process exponential, but also completely kills the idea of reusable APIs and separately distributable libraries, since the entire program must be available to the type checker in order to definitively derive the union type at a particular declaration site.

Is that a theoretical result published somewhere? And when they say constraint typing, they mean "constraint-based typing" right?

Seeking candidates to work on a custom compiler/language in NYC


Following up on this post suggesting that this would be a reasonable request to post ...

I am looking for candidates who would be interested in working on a JIT compiler for a custom Haskell-like programming language for a major investment bank in NYC. The project is still young, just under two years since inception, but is already actively used by several major trading applications. We use LLVM/MCJIT as a back-end and we produce code that can be integrated with C++ applications.

Our general mandate is to solve problems in the trading domain as safely, concisely, and efficiently as possible. There is significant support behind this effort; it's an unusual opportunity to bring recent ideas in programming languages to an immediate industry setting.

If you are interested in this project, and you have some experience writing compilers for functional programming languages with type systems similar to Haskell, please send an email to kthielen at gmail dot com.

Thank you.

general patterns in PL persistence schemes?

How many different basic strategies in programming language persistence seem like good ideas to support? The sort of perspective I want is a summary overview, as opposed to a detailed survey of every known tactic touched in literature. A gloss in a hundred words is better than a paper listing everything ever done in persistence.

(In chess a desire to "control the center" is the sort of basic pattern I have in mind, not an encyclopedia of all chess opening variations. In the context of PL tech, the sort of basic patterns I have in mind include image, document, database, file system, etc. But I'm interested an analytical assessment of effect of choosing a pattern.)

Some products featuring a PL as the main offering come coupled with a normative scheme for managing persistent storage. For example, Smalltalk was traditionally associated with image-based storage, though the language per se does not require it. Similarly, HyperTalk came bundled with stack-document storage as files in HyperCard. Other languages might come coupled with a database, or assume cloud-based resources.

I'm mainly interested in "local" storage schemes, like in desktop software, guiding a developer using a language in managing persistent state in session or project form. Yes, this assumes desktop software isn't dead yet. If a user creates content in documents, how does a language organize support for this? That kind of thing. Preventing users from making meaningful documents filled with self-contained data sets would be weird.

This line of inquiry comes from thinking about a language with a builtin virtual file system that unifies the interface for local and distributed data streams. How does one avoid antagonizing a user's need for documents? A document might be mounted as a file system, so saving is modeled as transacting changes on that file system, and two-phase-commit can be used to arrange consistent collections of changes across disparate stores. But this strikes me as a random data point without much context. So I'm interested in what kind of context is provided by other PL approaches to persistent services. Maybe the normal thing to do is say a language defers to an operating system or storage product.

XML feed