LtU Forum

EDSL for hardworking IT programmers

Dear all,

This is my first post to this site. So hi everyone. As a tiny bit of context, I've only recently started to look into functional programming, understanding some of the foundations and writing some simple Haskell.

I came across this article on entitled "An EDSL for hard working IT programmers". It only has a few comments on the Haskell Reddit and Hacker News.

To my unexperienced eyes, the approach proposed in the article - despite the strange title and somewhat disorienting writing - is quite significant and maybe profound which is why I'm asking this community whose expertise I deeply respect. The lack of echo anywhere makes me wonder if I might be wrong and if this is in fact a fairly common approach? Could you point me to equivalent solutions or explain more about why its not significant?

Thanks a lot for helping me understand more about the state of the art in functional programming!


SPLASH 2015 - Call for Contributions: Other Tracks

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

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

Sponsored by ACM SIGPLAN

Doctoral Symposium
Dynamic Languages Symposium (DLS)
OOPSLA Artifacts
Student Research Competition
Student Volunteers

Co-Located Conferences: SLE, GPCE, DBPL, PLoP

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.

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

Submissions Due: 30 June, 2015

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

Submissions Due: 30 June, 2015

** Dynamic Languages Symposium (DLS) **
The 11th Dynamic Languages Symposium (DLS) at SPLASH 2015 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.

Submissions Due: 15 June, 2015

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

Submissions Due: 9 June, 2015

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

Submissions Due: 30 June, 2015

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

Submissions Due: 30 June, 2015

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

Submissions Due: 30 June, 2015

** Student Volunteers **
The SPLASH Student Volunteer program provides an opportunity for students from around the world to associate with some of the leading personalities in industry and research in the following areas: programming languages, object-oriented technology and software development. Student volunteers contribute to the smooth running of the conference by performing tasks such as: assisting with registration, providing information about the conference to attendees, assisting session organizers and monitoring sessions.

Submissions Due: 7 August, 2015

** Tutorials **
The SPLASH 2015 Tutorials programme will consist of prestigious tutorials on current topics in software, systems, and languages research. The scope of Tutorials is the same as the conference itself: all aspects of software construction and delivery at the intersection of programming, languages, and software engineering. 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.

Submissions Due: 30 June, 2015

** Wavefront **
The SPLASH Wavefront track is looking for presentations and technology talks of interest to the software community, particularly to software professionals working in companies large and small. Wavefront is a forum for presenting experience reports and tutorials about innovative tools, technologies, and software practices.

Submissions Due: 30 June, 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.

Late Phase Submissions Due: 30 June, 2015

** Co-Located Events **

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

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

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

PLoP - 22nd International Conference on Pattern Languages of Programming (PLoP)
Submissions Due: 12 May, 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)
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)
PLMW Workshop Co-Chairs: Darya Kurilova (Carnegie Mellon University) and Zachary Tatlock (University of Washington)
Posters Co-Chairs: 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)
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)
Videos Previews Czar: Thomas LaToza (University of California, Irvine)
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)

More information about Albatross

The Albatross web page has been updated with information about the full language and the release plan.

message, stream and protocol typing

Suppose you want to type-check a message protocol, or a stream grammar, or partially ordered datagram exchange. The type signature might be declared in advance, or you might be told at runtime during negotiation.

What kind of type declarations comprehensible to average practitioners can work well enough without a lot of training or priesthood snake-oil? I ask because sometimes I see type expertise languishing in what looks like a backwater from my view. I want to type process pipelines, stream flows, crypto exchanges, and connection protocols.

I only ask to see if interesting ideas come up. A side channel in rumination recently was about static analysis of what might happen if shell command lines were executed, given sufficient meta-info declarations about dataflow behavior. I thought a developer might be interested in tool support for analysis of what happens given components that interact with specified finite state machines and message formats, etc. You can elaborate the idea further from there.

New abstract creative reasoning is what I'd like most, rather than existing work -- which I would expect to be narrow, concrete, unimaginative, and grinding in application. Of course I don't mind being contradicted with beautiful work.

Trouble understanding Danvy's functional unparsing

I've read Danvy's paper here[1], and I fail to understand why CPS is necessary for the types to work out. I've written a basic version of "functional sprintf" in OCaml that doesn't use CPS and seems to typecheck fine:

let int_ s i = s ^ string_of_int i

let float_ s i = s ^ string_of_float i

let (@) f g s a b = g (f s a) b

let sprintf fmt = fmt ""

let (_s : string) =
let x = sprintf (int_ @ float_) 1 1.0 in
let y = sprintf (int_ @ float_ @ int_) 1 1.0 2 in
x ^ y


Divergence not bottom?

Has anyone worked with a lambda calculus variant in which divergence is present as a value but different from bottom?

It seems like that might be a useful variant for me, so I wanted to see if it's been done or is obviously broken before hammering out the details.


Live Coding at Come Alive

This is neat:

Live Coding at Come Alive.

From the FAQ:

Alive is an extension to Visual Studio that instantly shows you what your code is doing.
It was created with one purpose: To provide immediate feedback to developers.

CEPTR presentation @ MIT KIT

(Requires WebEx Player.)

Art Brock & Eric Harris-Braun - "Just a Spoonful of Ceptr".

Ceptr evolved from the MetaCurrency Project as we needed to build distributed tools that went far beyond blockchain approaches. Ceptr provides semantic computing, a self-describing protocol stack, distributed/byzantine processing, fractal virtual machines, autonomous contracts and organizations, and more. Since it is such a wide-reaching project, we'll only be able to get a taste of it in a 1 hour webinar. So we've set up some demonstrations of how approaching things with Ceptr allows us to easily tackle problems which are normally intractable. After a bit of show and tell, we'll have time for questions and discussion about our tools and approach.

I think it is worth watching through this -- this presentation was the only thing so far I've seen on CEPTR that actually made me understand what is being talked about since they tend to have made up new lingo and don't always tell you what it is most like from the past. It has aspects of tuple spaces, of objects, of actors, or cap'n proto, IoT, etc.

From Programming Language Design (PLD) to Programmer Experience Design (PXD)

This is a fork of another topic.

I think it is high time that we stop talking about programming languages in isolation of the tools that support them. The tools have always depended on the languages, obviously, but increasingly the languages depend on the tools, especially in professional language design contexts. Dart and TypeScript are extreme examples of this where the type systems are there primarily to support tooling, and are much less about early error detection. As another example, C# design is heavily influenced by Visual Studio.

Designing a language invariably involves trade offs, and if we accept tools as part of the core experience, we are able to make decisions that are impossible given the language by itself. For example, many people find type inference bad because it obscures developer documentation, especially if it is not completely local. However, given an editor where inferred type annotations are easily viewed when needed, this is no longer a problem. Likewise, a type system that cannot provide good comprehensible error messages in the tooling is fundamentally broken, but tooling can be enhanced to reach that point of comprehensibility. Type systems in general are heavily intertwined with tooling these days, playing a huge role in features like code completion that many developers refuse to live without.

And of course, there are huge advances to be had when language and programming model design can complement the debugging experience.

There are other alternative opinions about this, to quote and reply to Andreas from the other topic:

Only if you do so for the right reason. Tooling is great as an aid, but making it a prerequisite for an acceptable user experience isn't. A language is an abstraction and a communication device. Supposedly, a universal means of expression, relative to a given domain. It fails to be a (human-readable) language if understanding is dependent on technical devices.

This is a good point: code should stand on its own as a human communication medium. However even our human communication is increasingly tool dependent, as we rely on things like the Google to extend our capabilities. We are becoming cyborgs whether we like it or not.

There are many other places than your editor where you need to read and understand code: in code reviews, in diffs, in VCSs, in debuggers, in crash dumps, in documentation, in tutorials, in books printed on paper.

Code isn't bound to paper. Even when printed out on paper, it does not need to printed out as it was typed in.

You can try to go on a life-long crusade to make every tool that ever enters the programming work flow "smart" and "integrated", and denounce books and papers as obsolete. But that is going to vastly increase complexity, coupling, and cost of everything, thus slows down progress, and just creates an entangled mess. And in the mean time, every programmer will struggle with the language.

This is more of an observation about current and future success of programming experiences. I would say it has already happened: successful programming languages already pay these costs, and new languages must either devote a lot of resources to tooling, or build them in at the beginning, or they simply won't be successful. Some people wonder why language X isn't successful, and then chalk it up to unenlightened

Nothing ideological or academic about that, just common sense.

Since an appeal to common sense is made, I would just think we have different world views. We at least exist in different markets.

A sketch of a "design papers/pearls" category in academic conferences

Recent LtU discussions have mentioned (eg. here) that it is hard to get programming language "design work" to get recognized academically. Good design work that is *also* accompanied by solid benchmarks or strong correctness argument will get recognized for the benchmarks or formal guarantees, but design work on domains that do not lend themselves to easy performance metrics, or done by people that do not use formalization as a validation tool will be hard to get recognized. A recent blog post by Jonathan Edwards echoes the same frustration (note that it also complains about the worse-is-better philosophy prevalent in industry not being good at fostering radical changes either).

(I would like to apologize to the part of the LtU community that does not care about academia. I try to keep my usual submissions/topics independent of professional occupation, and this one is the exception. Feel free to just skip it.)

There are some academic spaces where design work can stand of its own. I know of the Future of Programming workshop, the Onward! conference, and maybe (it's probably too soon to tell) the new SNAPL conference. However, at least the first two events are considered somewhat second-class in the academic community (which has an unfortunate tendancy to foster competitivity through metrics and will keep core of "top tier" conferences, creating strong incentives to publish only at the most selective/established places). ICFP has a "functional pearl" category (see Call For Papers (CFP), section "Special categories of papers") that counts as a first-class ICFP publication, ITP has a "rough diamond" category (CFP, but-last paragraph), Oleg just mentioned FLOPS "system descriptions" (it also has "declarative pearls", CFP, "Scope"), what would a category of "design papers" look like? (Yes, the idea is have a niche to protect endangered species that the free market would tend to root out; I think we can win big by dedicating a reasonable proportion of our scarce resources to fostering intellectual and methodological diversity.)

Here is a proposal for how it would be defined, or rather, how it would be reviewed (which I think is the subtle question):

Each proposed language/feature design must come with a working implementation. The author should highlight the proper domain area in the submission, and maybe make a few suggestion of potential programs to implement. Reviewers are then asked to actually implement some programs using this language/feature, and rate the system based on whether they enjoyed this implementation attempt.

(I don't know where such a category would fit; PLDI has a D for "Design" in the name, but then I don't know much about this conference.)

XML feed