Lambda the Ultimate
User loginNavigation |
LtU ForumFixed points considered harmfulFixed points have been an important topic ever since Church invented the lambda calculus in the early 1930s. However, the existence of fixed points has unfortunate consequences: Fortunately, types intuitively preclude the existence of fixed points, e.g., Paper journals are in bad shape; priority established in HAL ...In Computer Science, paper-based journals are in bad shape with unpaid refereeing not adding much value to articles. Papers are debugged by colleagues (including students). Also, page limits are a huge limitation of page-based journals. Publication in a paper-based journal is often for reasons like the following: Important information typically travels first electronically with publication in a paper-based journal sometimes following years later, if at all. Priority is often established by publication in HAL, etc. Books, (e.g. "Inconsistency Robustness") can be important in collecting and summarizing. The evolution of RustGraydon Hoare is the original developer of Rust even before Mozilla adopted it. For the 1.0 release he prepared a lightning talk on how the language changed over 10 years.
Read the full blog post for the content of the five lists. process oriented PL boot-strappingA few days ago I had a somewhat interesting idea about bootstrapping PL (programming language) tools and components after you assume a process-oriented architecture. This post amounts to sharing. The entertaining part, if there is one, will become apparent on reflection. To make this less concrete, I'll start with a minimal bit of abstraction about what process means. Suppose asp means abstract sequential process (chosen so pronounced as one syllable with an arbitrary concrete/visual image of a snake suggesting a chain of continuations). Then say nop means native os process, typically implying an address space and whatever the OS does in the way of a process. When you launch an app written in C on some platform, typically it starts a new nop and eventually gets around to calling main() in the main thread, which is the root of the asp which lives in that nop. An asp is something like a fiber, but a typical C program with no threads and no extra fibers will amount to one nop, one thread, and one fiber, thus seeming synonymous with the asp as executing code in a general sense. The idea of asp is only useful when you think about mapping it differently. You can run an asp in a thread (inside a nop), or you can run an asp inside a fiber (inside a thread inside a nop). If an asp talks to the world only via messages, for example using standard input and output streams, then you can map it somewhere else while preserving behavior. An asp run as a standalone nop would be similar in behavior to one run in a thread or fiber, but be much easier to debug that way in isolation, where it can't corrupt memory in another asp, for instance. It doesn't matter what language an asp is written in, when the only way you interact with it is via messages. Here's the part I find entertaining. To bootstrap, you can start with an asp written in a way you find totally unacceptable in the long run, as long as it helps you write new versions you run later with better properties. You can write an interpreter that's a slow memory hog that does everything slowly and monolithically, but use it to write assorted tools and transpilers that later run much more efficiently and asynchronously, perhaps compiling itself to a better form to use in subsequent invocations. Since every asp is independent, except to the extent it depends on cooperation of other entities it messages, you can run old and new versions of an asp at the same time, to compare in tests or to stage incremental service upgrades. The same general daemon nop architecture can be re-used in each version: something that spins ups and listens to connections, running asps in threads, perhaps inside fiber pools within. You can start with one as a root session that starts other daemon nops as requested, when you want parts of service isolated or restartable without a root session reset. Maybe one child nop is the virtual file system, for example. You can rebuild executables and launch new child nops with upgraded features to replace old inferior child nops, then shift service to new instances. As long as you are connecting everything with channels managed by daemon non-blocking i/o features, it doesn't matter how many native processes you have, or where things get assigned, and you can use config specs to change where things go. I thought it would be fun to be able to write terrible (but easy to understand) early versions of things that can generate new and better versions that run with identical external process interfaces you can swap dynamically. Bad scaffolding architecture doesn't need to infect or influence later improved versions. So you can start out writing things in the most general way you like, then slowly generate concrete translations of that into the target quality you want to read over time through stepwise evolution. This idea might help beginners in PL research, since it means you don't need to be especially careful about your starting point. Process separation implies disposable steps. EDSL for hardworking IT programmersDear 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! Jun SPLASH 2015 - Call for Contributions: Other Tracks/************************************************************************************/ Pittsburgh, Pennsylvania, USA Sponsored by ACM SIGPLAN /************************************************************************************/ 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 ** Submissions Due: 30 June, 2015 ** Doctoral Symposium ** Submissions Due: 30 June, 2015 ** Dynamic Languages Symposium (DLS) ** Submissions Due: 15 June, 2015 ** OOPSLA Artifacts ** Submissions Due: 9 June, 2015 ** Posters ** Submissions Due: 30 June, 2015 ** SPLASH-E ** Submissions Due: 30 June, 2015 ** Student Research Competition ** Submissions Due: 30 June, 2015 ** Student Volunteers ** Submissions Due: 7 August, 2015 ** Tutorials ** Submissions Due: 30 June, 2015 ** Wavefront ** Submissions Due: 30 June, 2015 ** Workshops ** Late Phase Submissions Due: 30 June, 2015 ** Co-Located Events ** SLE - 8th International Conference on Software Language Engineering (SLE) GPCE - 14th International Conference on Generative Programming: Concepts & Experiences (GPCE) DBPL - 15th Symposium on Database Programming Languages (DBPL) PLoP - 22nd International Conference on Pattern Languages of Programming (PLoP) Information: Location: Organization: By craiganslow at 2015-05-21 00:00 | LtU Forum | login or register to post comments | other blogs | 2754 reads
More information about AlbatrossThe Albatross web page has been updated with information about the full language and the release plan. message, stream and protocol typingSuppose 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 unparsingI'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 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) = [1]: http://www.brics.dk/RS/98/12/BRICS-RS-98-12.pdf 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. Thanks  |
Browse archives
Active forum topics |
Recent comments
8 weeks 6 days ago
8 weeks 6 days ago
8 weeks 6 days ago
9 weeks 10 hours ago
9 weeks 3 days ago
9 weeks 3 days ago
9 weeks 4 days ago
9 weeks 5 days ago
9 weeks 5 days ago
9 weeks 5 days ago