Lambda the Ultimate

Short description of the project would be a new programming language, cloud OS and crowdsourced community that collects donations.

12 page abstract is here

I'm working on a declarative configuration language for an application. The language is mostly structured data (think JSON). It also has variables, so you can define variables in one part of it and use them in another. You can import definitions from another file and its contents is merged with the local data in a predictable way. And you can extend substructures by referencing other substructures (a simple form of data inheritance, a bit like prototype-based objects without methods). The only control flow-like construct is a sequence, no branching, loops or conditionals.

The language is developed on a make-do basis, adding features as new requirements pop up. But I would like to base this against a more disciplined approach. Is there a theory for such primitive languages? Literature?

Hello. I've been lurking here for a while, but this is my first post. It's a request for advice that I hope more experienced PL scholars might be able to provide.

I'm an undergraduate student of computer science, about to enter my final year. This means I'll soon be required to begin work on a senior thesis. I'm pretty sure that I want to do something related to programming languages; I've always been fascinated by them, and greatly enjoyed the two courses on PL theory and implementation which my school offers.

My problem is that I don't know how to go about finding something to work on. Specifically, a research-ish problem related to programming languages that can feasibly be solved by an undergraduate spending about 20 hours per week on it for six months.

I like the idea of designing a language, and have a few vague ideas of how I might go about doing it, but I'm not sure what actual problem I'd be solving. I wouldn't be averse to a PL-related project that didn't involve designing a language.

So how might one find something to research that's the right level and scope for a senior thesis?

Thank you in advance.

A short 3 page workshop paper* submission. I've written to briefly describe Glitch. It has been a long journey from FRP signals to a model where I can actually write programs that I want to write.

Abstract:

Input changes are often handled by reactive and incremental constructs that are tedious to use and/or inexpressive, while changes to program code are not typically handled at all during execution, complicating support for "live programming." We propose that change in code and input should be managed automatically, similar to how garbage collection eliminates memory management as an explicit programmer concern. Our programming model, Glitch, realizes such managed time by progressively re-executing nodes of program execution when they become inconsistent due input/code state changes. Unlike many reactive models, Glitch supports expressive shared-state procedural programming, but with one caveat: operations on shared state must be undoable and commutative to ensure re-execution efficiency and eventual consistency. Still, complex programs like compilers can be written in Glitch using mundane programming styles.

* Apologies for using SkyDrive, it was just convenient. Use the download link and ignore the horrid Office 365 PDF viewer.

Global State Machines are an inadequate foundation for computation (contra Dijkstra and Gurevich et. al.)

A principle limitation relates to the inability of Global State Machines to represent concurrency. See What is computation? Actor Model versus Turing's Model

       Global State Machine References

Andreas Blass, Yuri Gurevich, Dean Rosenzweig, and Benjamin Rossman (2007a)
   Interactive small-step algorithms I: Axiomatization
   Logical Methods in Computer Science. 2007.
Andreas Blass, Yuri Gurevich, Dean Rosenzweig, and Benjamin Rossman (2007b)
   Interactive small-step algorithms II: Abstract state machines and the characterization theorem
   Logical Methods in Computer Science. 2007.

Edsger Dijkstra.
   A Discipline of Programming 
   Prentice Hall. 1976.
Edsger Dijkstra and A.J.M. Gasteren.
   A Simple Fixpoint Argument Without the Restriction of Continuity
   Acta Informatica. Vol. 23. 1986.

A language for programming brains from IBM research. Abstract:

Marching along the DARPA SyNAPSE roadmap, IBM unveils a trilogy of innovations towards the TrueNorth cognitive computing system inspired by the brain’s function and efficiency. The sequential programming paradigm of the von Neumann architecture is wholly unsuited for TrueNorth. Therefore, as our main contribution, we develop a new program- ming paradigm that permits construction of complex cognitive algorithms and applications while being efficient for TrueNorth and effective for programmer productivity. The programming paradigm consists of (a) an abstraction for a TrueNorth program, named Corelet, for representing a network of neurosynaptic cores that encapsulates all details except external inputs and outputs; (b) an object-oriented Corelet Language for creating, composing, and decomposing corelets; (c) a Corelet Library that acts as an ever-growing repository of reusable corelets from which programmers compose new corelets; and (d) an end-to- end Corelet Laboratory that is a programming environment which integrates with the TrueNorth architectural simulator, Compass, to support all aspects of the programming cycle from design, through development, debugging, and up to deployment. The new paradigm seamlessly scales from a handful of synapses and neurons to networks of neurosynaptic cores of progressively in- creasing size and complexity. The utility of the new programming paradigm is underscored by the fact that we have designed and implemented more than 100 algorithms as corelets for TrueNorth in a very short time span.

LambdaCube 3D is a domain specific language and library that makes it possible to program GPUs in a purely functional style.

Like, the game demo requires Haskell. More prose and code examples on the project blog.

Parallel Computing in the Julia Language

Most modern computers possess more than one CPU, and several computers can be combined together in a cluster. Harnessing the power of these multiple CPUs allows many computations to be completed more quickly. There are two major factors that influence performance: the speed of the CPUs themselves, and the speed of their access to memory. In a cluster, it’s fairly obvious that a given CPU will have fastest access to the RAM within the same computer (node). Perhaps more surprisingly, similar issues are very relevant on a typical multicore laptop, due to differences in the speed of main memory and the cache. Consequently, a good multiprocessing environment should allow control over the “ownership” of a chunk of memory by a particular CPU. Julia provides a multiprocessing environment based on message passing to allow programs to run on multiple processes in separate memory domains at once.

I mentioned this on one of the earlier threads on JVM security; it's the cumulation of my attempts to lock-down the JVM securely, and finally giving up and just writing my own. It's now reached the point where its actually pretty usable, with a good spread of test cases. Apart from the security angle, its small size would make it useful for doing all sorts of VM-related experimentation.

Metascala is a tiny metacircular Java Virtual Machine (JVM) written in the Scala programming language. Metascala is barely 3000 lines of Scala, and is complete enough that it is able to interpret itself metacircularly. Being written in Scala and compiled to Java bytecode, the Metascala JVM requires a host JVM in order to run.

The goal of Metascala is to create a platform to experiment with the JVM: a 3000 line JVM written in Scala is probably much more approachable than the 1,000,000 lines of C/C++ which make up HotSpot, the standard implementation, and more amenable to implementing fun features like continuations, isolates or value classes.

Parsing@SLE is a new workshop on parsing programming languages and other software languages. The intended participants are the authors of parser generation tools and parsers for programming languages and other software languages. For the purpose of this workshop "parsing" is a computation that takes a sequence of characters as input and produces a tree or graph shaped model as output. This possibly includes tokenization using regular expressions, deriving trees using context-free grammars, mapping to abstract syntax trees and perhaps even some semantic analysis.

The goal of the workshop is to bring together today's experts in the field of parsing, in order to explore open questions and possibly forge new collaborations. The topics may include algorithms, implementation and generation techniques, syntax and semantics of meta formalisms (BNF), etc. We expect to attract participants that have been or are developing theory, techniques and tools in the broad area of parsing non-natural languages such as programming languages and other software languages (domain specific languages, configuration languages, build languages, data description languages, query languages, etc.)

We solicit short abstracts, asking for positions, demonstrations and early achievements. The submissions will be reviewed on relevance and clarity, and used to plan the mostly interactive sessions of the day.

* workshop website
* Deadline August 15 2013
* Notification September 1 2013
* Submit a position paper