LtU Forum

Optimal efficiency

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?

SPLASH Call for Participation

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

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

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

28 September 2015 (Early Deadline)


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

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

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

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

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

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

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

Panel: The Future of Programming Languages and Programmers
With: Lars Bak, Rob DeLine, Nick Feamster, Lindsey Kuper, Crista Lopes, Peng Wu

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

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

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

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.

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

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

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

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

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

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


AGERE! - Programming based on Actors, Agents, and Decentralized Control

DSM - Domain-Specific Modeling

ETX - Eclipse Technology eXchange

FPW - Future Programming Workshop

MobileDeLi - Mobile Development Lifecycle

NOOL - New Object-Oriented Languages

PLATEAU - Evaluation and Usability of Programming Languages and Tools
Keynote: Mary Beth Rosson (Pennsylvania State University)

Parsing - Parsing @ SLE 2015

PROMOTO - Programming for Mobile and Touch

REBLS - Reactive and Event-based Languages & Systems

SMART - Smart Software Strategies

SEPS - Software Engineering for Parallel Systems

WODA - Workshop on Dynamic Analysis

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)

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

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

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


We gratefully acknowledge the generosity of our corporate supporters:

- Microsoft
- Oracle:
- NSF:

- IBM Research:
- Samsung:
- Intel:
- Google:
- HP:
- Huawei:

- DePaul University:
- The Royal Society Publishing:

Information and Organization

SPLASH Early Registration Deadline: 28 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 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":

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

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

Fabula programming language

A few years ago I presented here the Aha! programming language (general-purpose). Not long ago I decided to switch to the web development area and took a more pragmatic approach. The result is a new programming language for developing web applications - Fabula. Moreover, I developed a Fabula interpreter and then a complete online programming system in Fabula. Those who are interested can have a look at Any feedback is welcome.

Subclass, superclass, or siblings under an abstract superclass?

The usual pattern in software development is to put the simplest thing as a superclass and things with more complex behavior as a subclass.

But what happens when the values of the so-called superclass are actually a proper subset of the values of the subclass?

For example, in a neural network program, there are two classes; "Neuron" and "Neural_Structure." A Neural_Structure has members comprised of zero or more input points and one or more output points one or more of which are also backpropagation feedback points. An example of a Neural_Structure would be a unit in a "Pooling layer", which takes three inputs and then forward propagates one of them - whichever has the greatest absolute value or the most-positive or the most-negative value.

And the immediate impulse is that the Neural_Structure should be a subclass of Neuron because it is the more complex object, and to make it you need to add methods and overload a bunch of Neuron's methods.

But Neural_Structure generalizes Neuron rather than restricts it. It's the difference between an upperbound and a lowerbound relationship on the type. A Neuron is a Neural_Structure having one input point and one output point which is also a feedback point.

And in most PL's, we don't have a mechanism that would allow us to say "class Neural_Structure generalizes class Neuron" and add methods or add abstract methods or overload a bunch of Neuron's methods, and then allow us to use a Neuron anywhere a Neural_Structure is required.

So I wind up with an abstract superclass Neural_Structure where Neuron and Pooling_Node are both subclasses, and that's obviously the correct structure under classical OO paradigms. But "generalizes" rather than "extends" would have been more efficient, because Neural_Structure adds overhead and handling that Neuron doesn't need but which Neuron inherits.


Joining Forces: LVars & CvRDTs

More than a year old now, but I couldn't find it being mentioned on LtU. Apologies if this is a repeat / old news to everybody.

Joining Forces.
Although CvRDTs and LVars were developed independently, LVars ensure determinism under parallel execution by leveraging the same lattice properties that CvRDTs use to ensure eventual consistency. Therefore, a sensible next research question is: how can we take inspiration from CvRDTs to improve the LVars model, and vice versa? In this paper, we take steps toward answering that question in both directions: we consider both how to extend CvRDTs with LVar-style threshold reads and how to extend LVars with CvRDT-style inflationary updates, and we advocate for the
usefulness of these extensions.

PL vs. PX

I'm beginning to wonder if I'm in the wrong field. Many seems to be fixated on just language rather than resulting programming experiences (e.g. does this code look good vs. how was this code written?). The general sentiment of the field is clearly language-focused; e.g. take this post from pl-enthusiast:

From this vantage point, PL researchers tend to focus on developing general abstractions, or building blocks, for solving problems, or classes of problems. PL research also considers software behavior in a rigorous and general way, e.g., to prove that (classes of) programs enjoy properties we want, and/or eschew properties we don’t. ...

The ethos of PL research is to not just find solutions to important problems, but to find the best expression of those solutions, typically in the form of a kind of language, language extension, library, program analysis, or transformation.

So a focus on abstractions in the abstract, which is completely reasonable. But does is it really represent programming? Not really, PL doesn't seem to be about programming. It has applications to programming, but...

I’ve picked the three examples in the above discussion for a reason: They are an approach to solving general problems using PL-minded techniques in combination with techniques from other communities, like machine learning inference algorithms or cryptography.

So...PL is not about programming, rather it is a specific kind of theory field oriented around abstraction, which has applications for many other activities as well. In that case, my disillusionment with PL is just a matter of misguided expectation.

But that begs the question: what is a good academic home to talk about programming experiences, where PL is just a minor component of those activities? HCI? SE? None of those feel right.

After over two years and 1700 commits, the Nu Game Engine (the world's first practical pure functional game engine) reaches v1.0

The link - Nu Game Engine Release v1.0.0.0

The spiel -

Over two years in the making, and 1700 commits, the world's first practical, pure functional game engine, the Nu Game Engine, releases v1.0.0.0!

This release offer a greater guarantee of API stability than could be offered before.

I am hoping that Nu Game Engine will usher us toward an era of sustainable game development, because developer's lives matter, too! And if a game is torture to develop, its play experience isn't going to reach its potential.

Now that the days of being able to statically lay out the memory for an entire game are gone, it's time for developers to consider an alternative lifestyle where dynamism is a tool to be leveraged rather than eschewed.

Nu proves the efficacy and efficiency of game development with a pure functional API. Nu proves that hardcore optimizations like data-oriented physics engines, mutable spatial trees, and other computer-sympathetic data structures can be used transparently underneath a purely functional API.

Further, Nu proves that declarative programming style is also viable and sufficiently efficient for modern game development - Iterative Functional Reactive Programming with the Nu Game Engine

Whether or not people adopt Nu, I hope to at least offer it as proof that the prejudice against dynamism and functional programming in games at a high level is obsolete. And for those who don't believe, it's time to break out your profilers!

It's time for game developers to start having as much fun as we did so many years ago before we got run over by unbounded complexity!

@Moderator: Feel free to post to front page if deemed appropriate.

meta: September "propose a post" post (proposal)

I propose that once-per-month (or so), someone remember to create a "meta: <MONTH> "propose a post" post (proposal)".

There is no need for more than one "propose a post" topic per month (or so).

Within the comments of those monthly "propose a posts" posts people should follow the rules of a game.

The (voluntary) "rules" of the game:

(1) Top level comments propose "(new topic)" ltu posts that have not yet been made.

(2) 2nd level comments speak solely to the virtue of creating a new topic.

(3) No 3rd level comments and be brief, please.

(Just a proposal.)

Implementing "Elements of Programming" in Actor Script

In an effort to understand how ActorScript is to program with, and because I think Stepanov's "Elements of Programming" represents the best 'core' for any generic programming library, I want to try and translate the Elements into ActorScript. As there is no environment for actually testing code I thought I would post it here for comments from those who can tell if its correct or not. The idea is each top-level post should be a block of Elements code in ActorScript for comments. I will revise the top-level code according to the corrections and suggestions in the comments. I don't plan on using Unicode, but I will try and get the ASCII representations correct too.

XML feed