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:
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.
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:
What does everyone think about what our PL moonshots are or should be?
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?
the little nymph is for teaching purpose only.
it reuses the code and idea
to teach my friends
I will use assembly language (FASM for x86-64)
the programming language to be implemented
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 end ; define-macro : else << address, string[address, length] -- address, string[address, length] >> *branch* save-into,jo-heap x|swap|xx *current-free-address,jo-heap* xxx|swap|x 0 save-into,jo-heap << address, string[address, length], address >> *current-free-address,jo-heap* over sub *jo-size* div swap save end ; define-macro : then << address, string[address, length] -- string[address, length] >> x|swap|xx *current-free-address,jo-heap* over sub *jo-size* div swap save end ; define-macro
the following shows how to define factorial
: factorial << number -- number >> dup one? if end then dup sub1 factorial mul end ; define-function
for the code and more info ::
the main language I am designing is called cicada language
while the cicada nymph is a different language
This is an amazing paper that I've been anticipating ever since I read the abstract about half a year ago.
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.
Pittsburgh, Pennsylvania, USA
Sponsored by ACM SIGPLAN
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 **
Submissions Due: 25 March, 2015
** Onward! Research Papers **
Submissions Due: 2 April, 2015
** Onward! Essays **
Submissions Due: 2 April, 2015
** Workshops **
Early Phase Submissions Due: 25 March, 2015
** Dynamic Languages Symposium (DLS) **
Submissions Due: 7 June, 2015
** Co-Located Events **
8th International ACM SIGPLAN Conference on Software Language Engineering (SLE)
14th International Conference on Generative Programming: Concepts & Experiences (GPCE)
22nd International Conference on Pattern Languages of Programming (PLoP)
15th Symposium on Database Programming Languages (DBPL)
Artifact Evaluation Co-Chairs: Robby Findler (Northwestern University) and Michael Hind (IBM Research)
SLE General Chair: Richard Paige (University of York)
Can someone help me decode this comment from this post on Scala type inference:
Is that a theoretical result published somewhere? And when they say constraint typing, they mean "constraint-based typing" right?
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.
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.
Active forum topics
New forum topics