JavaScript, even more so than VB, has to be the Rodney Dangerfield of programming languages. I'm going to blow whatever credibility I might have by saying "I actually like programming in JavaScript." I'm actually building a lot of the screens in StoryTeller with JavaScript running in a WebBrowser control because I think I can do dynamic layout much faster with JavaScript than a WinForms screen. Besides, the point of a "side" project is to do stuff you don't get to do at your day job.
au:chlipala Ur introduces richer type system features into FP. Ur is functional, pure, statically-typed, and strict. Ur supports metaprogramming based on row types. Ur/Web is standard library and associated rules for parsing and optimization. Ur/Web supports construction of dynamic web applications backed by SQL databases. The signature of the standard library is such that well-typed Ur/Web programs "don't go wrong" in a very broad sense. They also may not: * Suffer from any kinds of code-injection attacks * Return invalid HTML * Contain dead intra-application links * Have mismatches between HTML forms and the fields expected by their handlers It is also possible to use metaprogramming to build significant application pieces by analysis of type structure - demo includes an ML-style functor for building an admin interface for an arbitrary SQL table. The Ur/Web compiler also produces very efficient object code that does not use gc
c2005 Most new ideas in software developments are really new variations on old ideas. This article describes one of these, the growing idea of a class of tools that I call Language Workbenches - examples of which include Intentional Software, JetBrains's Meta Programming System, and Microsoft's Software Factories. These tools take an old style of development - which I call language oriented programming and use IDE tooling in a bid to make language oriented programming a viable approach. Although I'm not enough of a prognosticator to say whether they will succeed in their ambition, I do think that these tools are some of the most interesting things on the horizon of software development. Interesting enough to write this essay to try to explain, at least in outline, how they work and the main issues around their future usefulness.
In most other programming languages, new abstractions are built by writing code on /top/ of existing abstractions. But in lisp, its possible to build new abstractions by writing code *beneath* existing code. Abstract: A partial evaluator automatically specializes a program with respect to some of its input. This article shows how the idea comes up naturally when you write program generators by hand, then builds a basic online partial evaluation library and puts it to work transforming an interpreter into a compiler. 0. Introduction Mainstream programmers think of writing an interpreter or a compiler as a major job, worth doing only for a major problem. They know this because the languages they use every day have big, serious implementations, and the compiler class they took in school had them write just one big, semi-serious compiler. Lispers know better: all the textbooks show how to write a Lisp interpreter in about a page of code.
One of the key goals of rewriting logic from its beginning has been to provide a semantic and logical framework in which many models of computation and languages can be naturally represented. There is by now very extensive evidence supporting the claim that rewriting logic is indeed a very flexible and simple logical and semantic framework. From a language design point of view the obvious question to ask is: how can a rewriting logic language best support logical and semantic framework applications, so that it becomes a metalanguage in which a very wide variety of logics and languages can be both semantically defined, and implemented? Our answer is: by being reflective. This paper discusses our latest language design and implementation work on Maude as a reflective metalanguage in which entire environments---including syntax definition, parsing, pretty printing, execution, and input/output---can be defined for a language or logic L of choice.
As you probably can tell Maude sets out to solve a different set of problems than ordinary imperative languages. It is a formal reasoning tool, which can help us verify that things are "as they should", and show us why they are not if this is the case. Maude lets us define formally what we mean by some concept in a very abstract manner, but we can describe what is thought to be the equal concerning our theory (equations) and what state changes it can go through (rewrite rules). This is useful to validate security protocols and critical code. The Maude system has proved flaws in cryptography protocols by just specifying what the system can do , and by looking for unwanted situations the protocol can be showed to contain bugs, not programming bugs but situations happen that are hard to predict just by walking down the "happy path" as most developers do. We can use Maude's built-in search to look for unwanted states, or it can be used to show that no such states can be reached.
Stratego/XT is a language and toolset for constructing stand-alone program transformation systems. It combines the Stratego transformation language with the XT toolset of transformation components, providing a framework for constructing stand-alone program transformation systems. The Stratego language is based around a programming paradigm called strategic term rewriting. It provides rewrite rules for expressing basic transformation steps. The application of these rules can be controlled using strategies, a form of subroutines. The XT toolset provides reusable transformation components and declarative languages for deriving new components. Program transformations often operate by modifying the (AST). In Stratego it is also possible to specify transformations using concrete syntax. This allows programmers to express a transformation using the familiar (and often more concise) syntax of the object programming language, while it internally still operates on the AST.
Most applications consist of a big number of model- or so called domain-objects. Building different views, editors, and reports; querying, validating and storing those objects is very repetitive and error-prone, if an object changes its shape frequently. Magritte is a fully dynamic meta-description framework that helps to solve those problems, while keeping the full power to the programmer in all aspects. Moreover since Magritte is described in itself, you can let your users modify the meta-world and add their own fields and forms without writing a single line of code.
Staged Meta Programming * MetaML does not restrict the stages to only run or compile Template Meta Programming * Template Haskell * C++ Templates Macro Systems Lexical macro systems are often independent of specific PL. Macro system that operate on a structured representations of source code are called syntax macros. Some macro systems allow the definition of a context-free syntax for the arguments of the macro. Hygience macro systems avoid unintended capturing of identifiers that are used in the context or in the macro definition. * Lisp Macros * Scheme R5RS Macros * Syntax macros in Bigwig * Maya Aspect-Oriented Programming * AspectJ * AspectL Quotation and Antiquotation * Camlp4 * SML/NJ Object Language Embedding with Quote/Antiquote * Isabelle's Logics * Programmable Syntax Macros * Meta Programming with Concrete Object Syntax Systems * GRAMPS
T. D'Hondt, K. Volder, K. Mens, and R. Wuyts. Software Architectures and Component Technology, page 207-224. Kluwer Academic Publisher, (January 2001)Proceedings of SACT 2000.
S. Marr, C. Seaton, and S. Ducasse. Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation, page 545--554. ACM, (June 2015)(acceptance rate 19%).
S. Marr, E. Gonzalez Boix, and H. Mössenböck. Proceedings of the 9th Arbeitstagung Programmiersprachen, volume 1559 of ATPS'16, page 91--95. CEUR-WS, (Feb 25, 2016)
S. Matsuoka, T. Watanabe, and A. Yonezawa. Proceedings of the European Conference on Object-Oriented Programming, page 231--250. London, UK, UK, Springer-Verlag, (1991)
J. McAffer. ECOOP’95 — Object-Oriented Programming, 9th European Conference, Åarhus, Denmark, August 7–11, 1995, volume 952 of Lecture Notes in Computer Science, Springer Berlin Heidelberg, (1995)