Lambda the Ultimate

An oldie (2000), but in my current (ignorant, admittedly) mind a goodie, from Igarashi & Kobayashi. I just wish the research hadn't apparently immediately died off? Garbage Collection Based on a Linear Type System. Or, chocolate + peanut butter.

We propose a type-directed garbage collection (GC) scheme for a programming language with static memory management based on a linear type system. Linear type systems, which can guarantee certain values (called linear values) to be used only once during program execution, are useful for memory management: memory space for linear values can be reclaimed immediately after they are used. However, conventional pointer-tracing GC does not work under such a memory management scheme: as linear values are used, dangling pointers to the memory space for them will be yielded.

This problem is solved by exploiting static type information during garbage collection in a way similar to tag-free GC. Type information in our linear type system represents not only the shapes of heap objects but also how many times the heap objects are accessed in the rest of computation. Using such type information at GC-time, our GC can avoid tracing dangling pointers; in addition, our GC can reclaim even reachable garbage. We formalize such a GC algorithm and prove its correctness.

I'd like some PL theory perspective on the idea outlined below, if you have relevant insight. Let me know if admin believes this is off-topic. But my interest is the PL angle, not the "let's write a cool app" angle. You can always hack away at getting a desired result without following any disciplined PL scheme, which isn't on-topic here.

As context, I want to start from a use-case, about processes interacting in a certain way. This is in contrast to how tech is sometimes discussed, first thinking of a neat formal idea, then trying to find a use. I want to start instead with a particular use and ask about any relevant neat formal ideas. My payoff is hearing ideas I would not have considered.

Instead of a boil-the-ocean scenario, where you pretend you can rewrite all software in a shiny new language, this use-case assumes things are not rewritten, that we operate in terms of whatever languages they use. So sometimes you talk to them in their own language, perhaps converting a new language to an old one at the boundary between new and old. Next is a concrete example scenario.

Suppose your new stuff goes in a new process that talks to others, like a browser and an IDE. If you have no UI frontend yourself, it looks like a daemon with one or more protocols to interact with other things. For example, a port serving http would let a browser interact easily with your process. This is especially easy because browsers are designed to work like that, but other standalone apps might also cooperate nicely, provided they have api to interact with other processes. I think this is true of emacs, to the extent you could use emacs as a frontend with a better IDE focus than a browser. Presumably other editors would also work as peers of your own process.

A browser likes Javascript, while emacs likes elisp, so presumably you would generate code to send them, if neither of those was a native focus in your process. (Altering a browser and/or an editor to understand your new paradigm is possible too, but it's interesting to work with existing tools that know nothing about you, and require no development changes at all.) Other tools will have their own preferred languages.

How do you go about doing that in a disciplined way with PL theory rigor? What PL concepts apply at different points and times? What general idea persists across different tools and languages? The new process speaking to each tool in its own language has some theory-of-mind about other tools, but that's not a PL concept as far as I know. Instead of winging each case in a one-off, specific, concrete way, what approach preserves some generality?

[I have little to add in discussion unless I think of questions about ideas suggested. It was recently suggested some things I say resemble a con artist's patter in some way, but I haven't been able to think of something I'm conning anyone about. I've had the same job for nine years, and it's boring. I don't look for a new job because web apps are not interesting to me, nor is commerce generally. I can't buff my reputation if I ignore social venues outside this one. I figure I'm pretty anonymous. I just crave interesting ideas. Coworkers want to talk about whether a local code style guide needs tuning; or if adventurous, they suggest rewriting tools in Erlang. So it's a creative desert. Being interested in PL topics is like being a Martian in places grinding away at the next incremental release.]

Edit: If you want code to run in a browser, you send it JS; if you want code to run in emacs, you send it elisp. (For some other executable, you send another language it wants.) The PL question is about being able to translate your model of code into another model, having a reason to believe qualities you want are present, and having something consistent in translation schemes.

Are these really the most cited or read?

Apparently this has not come up.

Halide (principle: Jonathan Ragan-Kelley). http://halide-lang.org/:

Halide is a programming language designed to make it easier to write high-performance image processing code on modern machines.

The core concept is apparently to split programs into two parts. One part of the program specifies the algorithm, which relates inputs to outputs. The other part of the program specifies the schedule, specifying which parts of the output should be computed when and where.

In lieu of a distinct surface syntax, Halide programs are apparently built by programmatically assembling ASTs:

Its front end is embedded in C++. Compiler targets include x86/SSE, ARM v7/NEON, CUDA, Native Client, and OpenCL.

You build a Halide program by writing C++ code using objects of type Halide::Var, Halide::Expr, and Halide::Func, and then calling Halide::Func::compile_to_file to generate an object file and header (good for deploying large routines), or calling Halide::Func::realize to JIT-compile and run the pipeline immediately (good for testing small routines).

Additionally, Dan Tull has a demo of "Live Coding Halide" for which there is a video here:

https://youtu.be/...

First, Learning to Execute on training neural nets to execute simple programs. Abstract:

Recurrent Neural Networks (RNNs) with Long Short-Term Memory units (LSTM) are widely used because they are expressive and are easy to train. Our interest lies in empirically evaluating the expressiveness and the learnability of LSTMs in the sequence-to-sequence regime by training them to evaluate short computer programs, a domain that has traditionally been seen as too complex for neural networks. We consider a simple class of programs that can be evaluated with a single left-to-right pass using constant memory. Our main result is that LSTMs can learn to map the character-level representations of such programs to their correct outputs. Notably, it was necessary to use curriculum learning, and while conventional curriculum learning proved ineffective, we developed a new variant of curriculum learning that improved our networks’ performance in all experimental conditions. The improved curriculum had a dramatic impact on an addition problem, making it possible to train an LSTM to add two 9-digit numbers with 99% accuracy.

Next, Neural Turing Machines on training Turing machines. Abstract:

We extend the capabilities of neural networks by coupling them to external memory resources, which they can interact with by attentional processes. The combined system is analogous to a Turing Machine or Von Neumann architecture but is differentiable end-toend, allowing it to be efficiently trained with gradient descent. Preliminary results demonstrate that Neural Turing Machines can infer simple algorithms such as copying, sorting, and associative recall from input and output examples.

Perhaps these are baby steps to a future field of neuro PL.

I'm at a crossroads in my research...my APX demo at strangeloop went well, and I learned a lot about live programming in the process. Hitting a target with a water hose and Hancock's steady frame (the visual information to guide one's aim) are very much key, and must be the focus of this work. Bret Victor's ideas in his learnable programming essay are nice and useful, but Chris Hancock provides the underlying reason on why they are so. In particular, scrubbing is a huge complement to live feedback, but so is direct manipulation when it can be managed, as well as the ability to abstract from a concrete implementation with concrete values into a general implementation. Its all about guided aiming.

On the one hand, what we have now is already kind of useful: at least having access to the execution while editing so you can just inspect anything you want at any time is a big advancement over dead programming. But on the other hand, the more powerful features, like scrubbing, are very limited to constants and simple abstractions that are easily placed in a continuum. They are not useful in general: abstractions are not easily placed in a continuum, and anyways have effects and outputs that are not intrinsically visual. If programming is to be revolutionized, we have to break out of that "2D box" into general usefulness.

So there is a lot of work can provide some inspiration on where to go now:

• Alexander Repenning's Conversational Programming. Basically, what if code completion could be augmented by execution context? Then you could more easily go from the "program you have" to the "program you want." It is still very visual, but it doesn't seem to be a very big stretch to make it general, leading us to...
• Joel Galenson's CodeHint system, which provides the results of a Java method call in the code completion call, allowing for more informed selection.
• Gilad Bracha also argues that methods should be made live during programming, that is development should be informed by live executions. I used to think that this wouldn't be good enough, but I'm now coming around to this view, at least partially (incremental re-execution can make for better feedback loops, managed time makes reactivity easier and allows for time travel/strobing, but none of that is necessary...). Heck, if you have values, you don't even need types to get good code completion, you can get better code completion even since you can inspect a specific run-time state!
• Conal Elliot's tangible functional programming. Automatically creates tangible interfaces for values (including functions), but they retain their abstractness.

One aspect that is kind of cool in APX is the ability to manipulate certain values in the visual view, and use that to create abstract-specific graphical interfaces that are used during programming; e.g. adjust the velocity of a ball as a vector directly in the editor. Nice, but I think this notion of graphical programmer interfaces (GPIs) can be applied more generally with the caveat that these interfaces feed on specific execution contexts. Text doesn't go away as text is abstract and concise, which is necessary in building scalable programs. But having graphical assists while editing code and debugging is quite useful.

So here are some driving examples to guide the next step that I've thought about so far:

• Consider writing a lexer. Given a variable x whose value is 'f', you want to build a condition that is true on 'f'. You bring up the code completion menu for members on x, and specify that you want only those members who evaluate to 'true', leaving you with a smaller set of members to choose from, including "isNonSpace", "isAlphaNumeric", and "isAlpha".
• Still writing a lexer, you have the string str whose value is "foo+ bar", you bring up code completion on str, select "count". Now you go to fill in count's argument, a predicate. Depending on what predicate you chose, count returns a different value, if you scrub the desired value of count to 3, you get fewer choices for this predicate, including "isAlphaNumeric" and "isAlpha". (Alternatively we could figure out how to do this in one action, since you might not want to commit to "count" until you figured out it had an argument you could use)
• Consider accessing the element of a dictionary, code completion for the key can show the literal values of the keys (and only those keys actually in the map), along with the values they evaluate to. Selecting a desired key, you can then "pick" some abstract expression that meets that key's value, thus making the code more abstract (we are programming against specific execution contexts, but we are still programming for the abstract!).
• Substring can allow you to select directly the part of the string that you want from an input string. You can then abstract those indices if necessary by finding expressions that compute them.
• As a simplification of the type state problem, code completion on a file shows "open" if the file's execution state is not open, or "close" if the file's execution state is "open". This is of course not "safe" for all execution contexts but it does allow one execution context to narrow the options (and it has to be safe for at least that context).
• When opening a file from a string, a file picker can come up to specify that string (this can be abstracted later as desired).
• Transforming a text file into something the program can use can be done with the aid of a GPI that knows what the text file is. So say you get:
  

  1.23,  45.6, 7.0
  5.734, 56.1, 0.66
  10,    0.8,  1.2
  

  The GPI can allow you to split it into rows via new lines (just select a visible NL character), split the rows into columns via the comma (select the comma), and it knows that the toDouble API will work for any column (and other string conversions won't work). This leads to a very efficient and safe file transformation process (with the caveat that it applies to only one execution context).

This really needs to work in two ways. First, a GPI can show you where you can go, and provide feedback about the consequences of going there. Second, we often need to work backwards from a concrete value to come up with an abstract expression that produces it. E.g. x - 30 or x / 2 where x is 60. The latter is much more difficult since it leaves the API open (the former has committed to an API), and their could be multiple APIs involved! For example, let's say I know I need the number 42 for the specific execution context, but to get there, I need to plug "foo" into dictionary "d" and access the bar field of that. Ugh. Even worse if we need to come up with a general arithmetic expression with very continuous inputs! Still, the connections needed to abstract a concrete value will often be simple (e.g. I need "42", x is just "42", use x), so perhaps it is just something used but isn't always usable. Also, there is not a good story yet for defining abstractions in a live programming context...e.g. new kinds of objects, ones that can remember some state to be used somewhere remote, or a new method. Perhaps this is also part of the create by abstracting process, I'm not sure.

(Ok, I wrote much more than expected, apologies!)

(This first sentence would have been a rhetorical question, because those are short and clear, but usually someone thinks I want a question answered, like I'm asking a homework question. So the next paragraph begins with the question. But it's rhetorical. It's only meant to frame a topic clearly as the top point of a reverse pyramid. Questions are good for that. It might have something to do with stupid headline style that inspires Betteridge's law of headlines.)

Do you have alternate ways of framing descriptions of program behavior with better results (clarity, concision, directness, etc.) in some domain, or class of application, which simplifies or untangles the pattern of desired activity? I ask for a couple reasons. First, there's not much traffic and I hope to spur a small amount of discussion. Second, I'm cooking up a fairly inchoate idea I might try to describe under this general heading. Rather than devote a topic to just my crazy idea, the general idea seems more interesting: how you describe a problem affects how easy it is to solve.

It's sort of an invitation to compare and contrast how you model what happens in code, including cliché paradigms like object-oriented or functional. But marketing prose for old stuff isn't what I hope to hear. (And I may write a dialog mocking a market pitch if really blatant. :-) Instead I hope to hear about less conventional ideas, whose explanation have an odd or surprising quality (even if it means half-baked and not obviously useful). This implies a weird ontology, if a programming language revolves around an unorthodox idea, because a programmer must think in terms of that model to write code. I anticipate no responses, though, except for "everyone must start using actors now", but a happy surprise would be nice.

I'll take a shot at describing my half-formed idea in a post later. But it hasn't gelled at all, and I'm even having trouble finding words that tend to imply the right thing. It involves viewing code as usually waiting for something to happen. For example, in a UI, menu items wait for you to select them, and a command line waits for you to enter another command. Installed programs wait for you to use them, and functions in a library wait for you to call them. Servers wait for requests, and network cards wait for packets. Writing code generally involves editing what is ready to react to stimulus in some form of input, usually with an aim to generate output or cause effects. But the word wait is a bad fit because it implies active waiting, with a purposive (almost teleological) framing that doesn't include the necessary aspect of passive option. Starting from option seems equally valid, and other words too perhaps. There's more, but just as unclear so far.

Edit: An idea which doesn't gel can sound tautological, making you ask: What is the point? Exploring a thread can cause every loose end to dry up so you only know what you knew before, that you merely tried an awkward angle.

Reading about Constraint Handling Rules, there is a claim that CHR is the first declarative language for which optimum efficiency of implementing all algorithms can be proved, and that this cannot be proved for the pure part of logic (eg Prolog), rewriting (eg Maude), or functional programming (eg Haskell), without adding imperative features.

Should we all be trying to develop languages based on CHR, rather than functional? What other language types to proofs (or disproofs) exist for optimal efficiency?

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

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

http://www.splashcon.org
https://twitter.com/splashcon
https://www.facebook.com/SPLASHCon

Sponsored by ACM SIGPLAN

/**************************************************************
2nd CALL FOR PARTICIPATION
**************************************************************/

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 inviting calls for participation.


** REGISTRATION **
28 September 2015 (Early Deadline)
Contact: info@splashcon.org
http://2015.splashcon.org/attending/registration


** CONFERENCE PROGRAM **
http://2015.splashcon.org/program/program-splash2015


** KEYNOTE Speakers **

We are delighted to announce the following keynote speakers at SPLASH 2015:

- Nick Feamster (Princeton University): Tomorrow’s Network Operators Will Be Programmers
- Lars Bak (Google): How Dart Learned From Past Object-Oriented Systems
- Rob DeLine (Microsoft Research): Modern software is all about data. Development environments should be, too.

http://2015.splashcon.org/track/splash2015-keynotes


**SPLASH-I Speakers **

SPLASH-I is a series of industrial research talks that address topics relevant to the SPLASH community. Speakers are world-class experts in their field, selected and invited by the organizers. The SPLASH-I talks series is held in parallel with the OOPSLA main track. Talks are open to all attendees.

- Avik Chaudhuri (Facebook): Flow: a static type checker for JavaScript
- Hassan Chafi (Oracle Labs): Domain Specific Languages @ Oracle Labs: Current Experiences, Future Hopes
- Chris Granger: Eve
- Shan Shan Huang (LogicBlox): Model, Execute, Deploy: Answering the Hard Questions about End-user Programming
- Lindsey Kuper (Intel Labs): Prospect: Finding and Exploiting Parallelism in a Productivity Language for Scientific Computing
- Simon Marlow (Facebook): Fighting Spam with Haskell
- Mark S. Miller (Google): Security as Extreme Modularity: A Standards Shaping Approach
- Eliot Miranda (Cadence): Spur: Efficient Support for Live Programming in Dynamic Languages
- Markus Voelter (independent): Language-Oriented Business Applications: Helping End Users become Programmers
- Josh Watzman (Facebook): Changing Engines in Flight: Facebook's Conversion to Hack
- Peng Wu (Huawei America Lab): When CT meets IT: Programming Challenges in the age of ICT Convergence

http://2015.splashcon.org/track/splash2015-splash-i


** 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).

http://2015.splashcon.org/track/oopsla2015

** 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.

http://2015.splashcon.org/track/onward2015-papers


** 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.

http://2015.splashcon.org/track/onward2015-essays

** DLS - Dynamic Languages Symposium **
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.

Keynote: Declare Your Language
Speaker: Eelco Visser (Delft University of Technology)

http://2015.splashcon.org/track/dls2015

** Panels **
The Panels track offers exciting discussion about topics related to SPLASH.

Panel: Software Professionalism – Is it “Good Enough?”
With: Dennis Mancl, Nancy Mead, Mary Shaw, Werner Wild
http://2015.splashcon.org/event/splash2015-panels-software-professionalism-is-it-good-enough-

Panel: The Future of Programming Languages and Programmers
With: Lars Bak, Rob DeLine, Nick Feamster, Lindsey Kuper, Crista Lopes, Peng Wu
http://2015.splashcon.org/event/splash2015-panels-the-future-of-programming-languages-and-programmers

** SPLASH-E **
The SPLASH-E track brings together researchers and educators to share educational results, ideas, and challenges centered in Software and Programming Languages. Submission formats vary, including papers, tool demos, lightning talks, challenge-topics for discussion, and suggested themes for "unconference" sessions. Help us create an engaging forum for educational issues related to SPLASH!

http://2015.splashcon.org/track/splash-e


** Artifacts **
The Artifact Evaluation process is a service provided by the community to help authors of accepted papers provide more substantial supplements to their papers so future researchers can more effectively build on and compare with previous work. The Artifact Evaluation Committee has been formed to assess how well paper authors prepare artifacts in support of such future researchers. Roughly, authors of papers who wish to participate are invited to submit an artifact that supports the conclusions of the paper.

http://2015.splashcon.org/track/splash2015-artifacts


** Workshops **
The SPLASH Workshops track will host a variety of high-quality workshops (13 in total), 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.

http://2015.splashcon.org/track/splash2015-workshops

Selected Workshop keynotes:

- AGERE! Daniel Wendel,
Concurrent, Distributed Thinking for First-time Programmers in StarLogo Nova

- MobileDeLi: Robert Seacord
Mobile Security

- PLATEAU: Mary Beth Rosson
Computational Thinking for All: Expanding the Boundaries of Computing for Nonprogrammers

- Parsing@SLE: Christian Kästner
Parsing Unpreprocessed C Code - The TypeChef Experience

- WODA: Koushik Sen
Concolic Testing: A Decade Later


** Tutorials **
The SPLASH Tutorials track will consist of prestigious tutorials on current topics in software, systems, and languages research. The scope of the tutorials is the same as the conference itself: all aspects of software construction and delivery at the intersection of programming, languages, and software engineering. The tutorials in particular focus on the nexus between research and practice, including work that takes inspiration from or builds connections to areas not commonly considered at SPLASH. Tutorials should introduce researchers to current research in an area, or show important new tools that can be used in research.

http://2015.splashcon.org/track/splash2015-tutorials


** Demos **
The SPLASH Demonstrations track is an excellent vehicle for sharing your latest work with an experienced and technically savvy audience. Live demonstrations show the impact of software innovation. Demonstrations are not product sales pitches, but rather an opportunity to highlight, explain, and present interesting technical aspects of running applications in a dynamic and highly interactive setting. Presenters are encouraged to actively solicit feedback from the audience, which should lead to very interesting and entertaining demonstration sessions.

http://2015.splashcon.org/track/splash2015-demos


** Posters **
The SPLASH Poster track provides an excellent forum for authors to present their recent or ongoing projects in an interactive setting, and receive feedback from the community. We invite submissions covering any aspect of programming, systems, languages and applications. The goal of the poster session is to encourage and facilitate small groups of individuals interested in a technical area to gather and interact. It is held early in the conference, to promote continued discussion among interested parties. Posters can be independent presentations or associated with one of the other parts of SPLASH.

http://2015.splashcon.org/track/splash2015-posters


** Doctoral Symposium **
The SPLASH Doctoral Symposium provides students with useful guidance for completing their dissertation research and beginning their research careers. The Symposium will provide an interactive forum for doctoral students who have progressed far enough in their research to have a structured proposal, but will not be defending their dissertation in the next 12 months.

http://2015.splashcon.org/track/splash2015-ds


** Student Research Competition **
The ACM SIGPLAN Student Research Competition (ACM SRC) is an internationally-recognized venue that enables undergraduate and graduate students to experience the research world, share their research results with other students and SPLASH attendees. The competition has separate categories for undergraduate and graduate students and awards prizes to the top three students in each category. The ACM SIGPLAN Student Research Competition shares the Poster session’s goal to facilitate interaction with researchers and industry practitioners; providing both sides with the opportunity to learn of ongoing, current research.

http://2015.splashcon.org/track/splash2015-src


** PLMW - Programming Languages Mentoring Workshop **

The purpose of Programming Languages Mentoring Workshop (PLMW) is to give promising undergraduate students from around Pittsburgh who consider pursuing a graduate degree in this field an overview of what research in this field looks like and how to get into and succeed in graduate school. In other words, a combination whirlwind tour of this research area, networking opportunity, and how-to-succeed guide. The program of PLMW will include talks by prominent researchers of the field of programming languages and software engineering providing an insight in their research.

http://2015.splashcon.org/track/splash2015-plmw


** RPG Richard's Pretty Good Talks **

RPG is my micro-conference. RPG is sporadically held, suddenly announced, and leaves little but mental limps and frustration / aka instability—take it as step #1 toward getting you decanalized. I choose the speakers and I don’t care what you think; I choose the topics and I always choose first loves. I want people telling me about things they cherish / not about how they make their living. Here’s what I’ve got going this year for the third edition.

- Crista Lopes & Annette Vee, Programming as Writing (and vice versa?)
- Billy Price & William Pollak, Singing the Blues / What is a Song?

http://2015.splashcon.org/track/splash2015-rpg


/**************************************************************
Workshops
**************************************************************/

AGERE! - Programming based on Actors, Agents, and Decentralized Control
http://2015.splashcon.org/track/agere2015

DSM - Domain-Specific Modeling
http://2015.splashcon.org/track/dsm2015

ETX - Eclipse Technology eXchange
http://2015.splashcon.org/track/etx2015

FPW - Future Programming Workshop
http://2015.splashcon.org/track/fpw2015

MobileDeLi - Mobile Development Lifecycle
http://2015.splashcon.org/track/mobiledeli2015

NOOL - New Object-Oriented Languages
http://2015.splashcon.org/track/nool2015

PLATEAU - Evaluation and Usability of Programming Languages and Tools
Keynote: Mary Beth Rosson (Pennsylvania State University)
http://2015.splashcon.org/track/plateau2015

Parsing - Parsing @ SLE 2015
http://2015.splashcon.org/track/ParsingAtSLE2015

PROMOTO - Programming for Mobile and Touch
http://2015.splashcon.org/track/promoto2015

REBLS - Reactive and Event-based Languages & Systems
http://2015.splashcon.org/track/rebls2015

SMART - Smart Software Strategies
http://2015.splashcon.org/track/SmartSoftwareStrategies2015

SEPS - Software Engineering for Parallel Systems
http://2015.splashcon.org/track/seps2015

WODA - Workshop on Dynamic Analysis
http://2015.splashcon.org/track/woda2015

/**************************************************************
Co-Located Events
**************************************************************/

** SLE - 8th International ACM SIGPLAN Conference on Software Language Engineering **

Software Language Engineering (SLE) is the application of systematic, disciplined, and measurable approaches to the development, use, deployment, and maintenance of software languages. The term “software language” is used broadly, and includes: general-purpose programming languages; domain-specific languages (e.g. BPMN, Simulink, Modelica); modeling and metamodeling languages (e.g. SysML and UML); data models and ontologies (e.g. XML-based and OWL-based languages and vocabularies).

Keynote Speaker: Stephane Ducasse (Inria)

http://2015.splashcon.org/track/sle2015


** GPCE - 14th International Conference on Generative Programming: Concepts & Experiences **

The International Conference on Generative Programming: Concepts & Experiences (GPCE) is a venue for researchers and practitioners interested in techniques that use program generation, domain-specific languages, and component deployment to increase programmer productivity, improve software quality, and shorten the time-to-market of software products. In addition to exploring cutting-edge techniques of generative software, our goal is to foster further cross-fertilization between the software engineering and the programming languages research communities.

Keynote Speaker: Priya Narasimhan (Carnegie Mellon University)

http://2015.splashcon.org/track/gpce2015


** DBPL - 15th Symposium on Database Programming Languages **

For over 25 years, DBPL has established itself as the principal venue for publishing and discussing new ideas at the intersection of databases and programming languages. Many key contributions in query languages for object-oriented data, persistent databases, nested relational data, and semistructured data, as well as fundamental ideas in types for query languages, were first announced at DBPL. This creative research area is broadening into a subfield of data-centric computation, currently scattered among a range of venues. DBPL is an established destination for such new ideas and solicits submissions from researchers in databases, programming languages or any other community interested in the design, implementation or foundations of data-centric computation.

Keynote: Gremlin: A Stream-Based Functional Language for OLTP and OLAP Graph Computing
Speaker: Marko A. Rodriguez (DataStax)

http://2015.splashcon.org/track/dbpl2015


** PLoP - 22nd International Conference on Pattern Languages of Programming **

The Pattern Languages of Programs (PLoP) conference is a premier event for pattern authors and pattern enthusiasts to gather, discuss and learn more about patterns and software development. The conference promotes development of pattern languages on all aspects of software, including design and programming, software architecture, user interface design, domain modeling, software processes, project management, and more. The program offers pattern authors an unique opportunity to have their pattern languages reviewed by fellow authors, which occurs mainly in the form of Writers’ Workshops.

Keynote: Progress Toward an Engineering Discipline of Software
Speaker: Mary Shaw (Carnegie Mellon University)

http://2015.splashcon.org/track/plop2015

/**************************************************************
Supporters
**************************************************************/

We gratefully acknowledge the generosity of our corporate supporters:

Silver:
- Microsoft http://www.microsoft.com/
- Oracle: http://www.oracle.com/
- NSF: http://www.nsf.gov/

Bronze:
- IBM Research: http://www.research.ibm.com/
- Samsung: http://www.samsung.com/
- Intel: http://www.intel.com/
- Google: http://www.google.com/
- HP: http://www.hp.com/
- Huawei: http://www.huawei.com/

Other:
- DePaul University: http://www.depaul.edu/
- The Royal Society Publishing: http://rsos.royalsocietypublishing.org/content/computer-science


/**************************************************************
Information and Organization
**************************************************************/

Information:
SPLASH Early Registration Deadline: 28 September, 2015
Contact: info@splashcon.org
Website: http://2015.splashcon.org

Location:
Sheraton Station Square Hotel
Pittsburgh, Pennsylvania, United States

Organization:
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 Jr. (Oracle Labs)
DLS Papers Chair: Manuel Serrano (INRIA)

Artifacts Co-Chairs: Robby Findler (Northwestern University) and Michael Hind (IBM Research)
Demos Co-Chair: Igor Peshansky (Google) and Pietro Ferrara (IBM Research)
Doctoral Symposium Chair: Yu David Liu, State University of New York (SUNY) Binghamton
Local Arrangements Chair: Claire Le Goues (Carnegie Mellon University)
Panels Chair: Steven D. Fraser (Independent Consultatnt)
PLMW Workshop Co-Chairs: Darya Kurilova (Carnegie Mellon University), Zachary Tatlock (University of Washington), and Crista Lopes (UC Irvine)
Posters Co-Chairs: Nick Sumner (Simon Fraser University) and Jeff Huang (Texas A&M University)
Publications Chair: Alex Potanin (Victoria University of Wellington)
Publicity and Web Co-Chairs: Craig Anslow (Middlesex University) 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)
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)
Sponsorship Chair: Tony Hosking (Purdue University)
Tutorials Co-Chair: Romain Robbes (University of Chile) and Ronald Garcia (University of British Columbia)
Video Chair: Michael Hilton (Oregon State University)
Video Previews Czar: Thomas LaToza (George Mason University)
Wavefront Co-Chairs: Dennis Mancl (Alcatel-Lucent) and Joe Kiniry (Galois)
Web Technology Chair: Eelco Visser (TU Delft)
Workshop 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 Chair: James Cheney (University of Edinburgh) and Thomas Neumann (TU Munich)

I did a search and could not find any references on LtU about "LMNtal":
http://www.ueda.info.waseda.ac.jp/~ueda/pub/chrworkshop-ueda.pdf

Abstract. LMNtal (pronounced “elemental”) is a simple language model
based on hierarchical graph rewriting that uses logical variables to represent
connectivity and membranes to represent hierarchy. LMNtal is an
outcome of the attempt to unify constraint-based concurrency and Constraint
Handling Rules (CHR), the two notable extensions to concurrent
logic programming. LMNtal is intended to be a substrate language of
various computational models, especially those addressing concurrency,
mobility and multiset rewriting. Another important goal of LMNtal has
been to put hierarchical graph rewriting into practice and demonstrate
its versatility by designing and implementing a full-fledged, monolithic
programming language. In this paper, we demonstrate the practical aspects
of LMNtal using a number of examples taken from diverse areas
of computer science. Also, we discuss the relationship between LMNtal
and CHR, which exhibit both commonalities and differences in various
respects.

It supports hierarchical structures using "membranes" and graph structures using "links", and concurrency via concurrent constraint programming and (some part of) constraint handling rules.