LANGUAGE-ORIENTED PROGRAMMING VIA DSL STACKING
Bernhard G. Humm Darmstadt University of Applied Sciences, Department of Computer Science, Darmstadt, Germany
Ralf S. Engelschall Capgemini sd&m Research, Munich, Germany
Keywords: Language-oriented programming, Extensible programming languages, Domain-specific languages, Meta pro- gramming, Semantic web, Business information systems, Lisp.
Abstract: According to the paradigm of Language-Oriented Programming, an application for a problem should be im- plemented in the most appropriate domain-specific language (DSL). This paper introduces DSL stacking, an efficient method for implementing Language-Oriented Programming where DSLs and general-purpose lan- guages are incrementally developed on top of a base language. This is demonstrated with components of a business information system that are implemented in different DSLs for Semantic Web technology in Lisp.
1 INTRODUCTION purpose. Like all software engineering paradigms, When analyzing large-scale commercial IT projects Language-Oriented Programming ultimately serves today, you usually find that five or even more lan- one goal: to allow for developing applications of guages are being used – even in a “pure Java project” high-quality at reasonable cost. To this end, which if you take a closer look. HTML and JavaScript may criteria do we expect from a DSL most appropriate be used for GUI programing, SQL or EJBQL for for a particular domain and why? database accesses, UML for data modeling, Perl for Sufficient Semantic Expressiveness. The DSL the UML to Java generator, BPEL for process logic must allow to express logic necessary for the and several XML dialects for configuration. Why respective application domain directly in the would projects put up with the high costs of hetero- language, e.g., rules in a knowledge-based geneity? This is because different problem domains system. This is necessary for implementing the require different language constructs. application at all. This is the main idea of a paradigm called Language-Oriented Programming (Ward, 1994; Conciseness and Comprehensibility. Statements Fowler, 2005; Dmitriev, 2005; Brauer et al., 2008). should be expressed adequately, i.e., as concisely It can be briefly summarized as follows. When you and comprehensibly as possible. Boilerplate code have to solve a complex problem, first choose – should be avoided. Inadequate representation has or, if necessary, develop – a language that is most several drawbacks. Firstly, developing unneces- appropriate for the problem. Then, implement the sarily voluminous code increases the costs for de- solution in this language. veloping the application. Even higher are the In most publications today, such a language follow-up costs for maintenance. Secondly, the is called a Domain-Specific Language (DSL) (van quality of the solution decreases since errors can- Deursen et al., 2000) – see Sect. 5.2. Earlier pub- not be detected as easily. The more adequate the lications use the term Problem-Oriented Language representation – i.e., the closer to the problem do- (Goldfinger, 1961). In this paper we stick to the term main – the more problem domain experts can be DSL although it shall be noted that the problem area involved in the development. does not have to be a business domain and the lan- Integration. It must be possible to integrate the DSL guage may be more or less specific, depending on its application with other applications, possibly im-
279 G. Humm B. and S. Engelschall R. (2010). LANGUAGE-ORIENTED PROGRAMMING VIA DSL STACKING. In Proceedings of the 5th International Conference on Software and Data Technologies, pages 279-287 DOI: 10.5220/0002925402790287 Copyright c SciTePress ICSOFT 2010 - 5th International Conference on Software and Data Technologies
plemented in other DSLs. This includes invoca- DSLs. The Unix little languages like AWK (Aho tion at run-time and, ideally, integrated develop- et al., 1988) or make (Feldman, 1979) are examples ment including integrated debugging. Integration of DSLs. is mandatory if the DSL application is a compo- Recently, there have evolved a number of nent of a larger application, e.g., a business infor- Language-Oriented Programming initiatives. Apart mation system. Integrated development decreases from OMG’s MDA initiative these are the STEPS development costs, particularly for testing and de- project (Kay et al., 2008), Microsoft’s “Software bugging. Factories” (Greenfield, 2004), “Intentional Program- Performance. Applications implemented in the DSL ming” (Simonyi et al., 2006) and the “Meta- must meet the respective performance require- Programming System” (Dmitriev, 2005). In those ments. publications, the term “language workbench” is used as an integrated environment to design and implement Those aspects help the application developer (de- DSLs and to program applications in those DSLs. signer and implementer). Language-Oriented Pro- Additionally, a number of new extensible pro- graming adds another role: the language developer gramming languages like F#, Ruby, Groovy, and (designer and implementer). The following aspect Scala have evolved in the last decade. They explicitly helps the language developer. provide features for language-oriented programming Efficient DSL Development. The design, imple- like Groovy’s Meta-Object Protocol (MOP). mentation including validation logic, testing, and Two approaches to Language-Oriented Program- maintenance of DSLs should be as efficient as ming can be distinguished: external DSLs and inter- possible. Efficient DSL development directly af- nal DSLs (Fowler, 2005). fects the total development cost. Internal DSLs are idiomatic ways of writing higher- In this paper, we present a method for Language- level language code in the host language of the Oriented Programming called DSL Stacking. DSL application (“base language” – see Sect. 5.2) stacking may meet all the criteria described above. directly. Example: AllegroProlog, a Prolog We demonstrate this with a sample Lisp application (Clocksin and Mellish, 1987) implementation by using Semantic Web technology in the insurance busi- Franz Inc. fully integrated in Lisp that allows Pro- ness. log programming in Lisp notation. The extensible This article is structured as follows. Sect. 2 and programming language initiatives all fall into this 3 give an overview of Language-Oriented Program- category. ming, Semantic Web technology, the insurance sam- External DSLs are different from the base language. ple and Lisp. In Sect. 4 we present a family of DSLs DSL programs are scanned, parsed and trans- for applying Semantic Web technology in the insur- formed into the base language using some form of ance business. Sect. 5 explains the concept of DSL compiler or interpreter. Example: a BPEL (OA- stacking. In Sect. 6, we discuss the results. Sect. 7 SIS, 2007) engine parses XML code and trans- concludes this article. forms it into data structures of a programming lan- guage like Java. The Unix little languages and MDA fall into this category. External DSLs may be embedded in a host language, e.g., as strings, 2 LANGUAGE-ORIENTED or may be programmed in separate files. PROGRAMMING In this paper, we focus on internal DSLs. The term Language-Oriented Programming (Ward, 1994; Fowler, 2005; Dmitriev, 2005; Brauer et al., 2008) has already been used for a number of years. 3 SAMPLE DOMAIN: SEMANTIC The idea, however, is even much older and has been WEB TECHNOLOGY IN THE around since the invention of the first high-level pro- gramming languages. There have been a number INSURANCE BUSINESS of extensible language initiatives in the 1960 and 1970s, e.g, translator writing systems like “The Syn- 3.1 Semantic Web Standards tax Directed Compiler” (Irons, 1961) or extensible programming languages like Lisp (McCarthy, 1960), The World Wide Web Consortium (W3C) has stan- IMP (Irons, 1970), and Smalltalk-72 (Kay, 1993). dardized a number of languages under the term “Se- Extensible languages facilitate the development of mantic Web” (Berners-Lee et al., 2001). The lan-
280 LANGUAGE-ORIENTED PROGRAMMING VIA DSL STACKING
guages are based on the technologies XML and URI. insurance-example#Heart-Stroke"> The main Semantic Web standards are as follows (World Wide Web Consortium (W3C), 2010). RDF (Resource Description Framework) is the ba- sic Semantic Web modeling language. The funda- Ten lines of XML code are necessary for expressing mental data structure is a triple consisting of sub- a simple triple. With this verbose code, RDF/XML ject, predicate, and object. is certainly no adequate representation for Semantic RDF-S (RDF Schema) builds on top of RDF adding Web programming. Other representations more or the concepts of classes and properties. less alleviate shortcomings of RDF/XML to provide a more concise and human-comprehensible form – one OWL (Web Ontology Language) builds on top of of the main concerns of Language-Oriented Program- RDF-S and adds expressive set-based logic. ming. SPARQL (SPARQL Protocol and RDF Query Lan- guage) allows for querying RDF-S and OWL 3.4 Business Domain: Insurance statements. We have developed a family of DSLs and have imple- 3.2 RDF Triples mented an insurance example application using those DSLs. The example is about issuing disability insur- The triple is the basic yet powerful data structure of ance. The customer interested in a disability insur- RDF. Every triple consists of subject, predicate, and ance must provide, apart from personal data, infor- object. See Figure 1. It allows for basic statements mation about employment, financial situation, health, like “Peter has an income of $ 65,000”. It further- and lifestyle. Based on this situation, the applica- more allows statements about class / instance rela- tion will perform a customer rating. For example, se- tionships as in “Peter is a Person” and “Person is a vere diseases present in the family history may lead to Class”. It also allows statements about properties like the decision of not offering a policy to the applicant. “has-income is a Property”. Based on the rating, the application automatically ac- cepts or declines the application or involves human
Peter has-income 65,000 intervention.
Peter rdf:type Person 3.5 Lisp as Base Language
Person rdf:type rdfs:class Lisp (McCarthy, 1960) is one of the earliest high-level programming languages. To date, numerous dialects
has-income rdf:type rdf:Property and versions have been specified and implemented. Two aspects of Lisp make it ideal for developing in- Figure 1: RDF triples. ternal DSLs: Code is Data. Lisp data are represented by sym- 3.3 Serialization Syntaxes for RDF bolic expressions, so-called S-expressions (Mc- Carthy, 1960). S-expressions are atoms like Different serialization syntaxes for RDF have been numbers or characters and arbitrary lists of S- standardized: RDF/XML, N3, Turtle, and N-Triples. expressions. Lisp programs are also expressed as The W3C recommends RDF/XML for exchanging S-expressions: function definitions, control struc- RDF triples. tures, class declarations etc. So, the syntax tree The following code example implements an RDF of Lisp code is directly expressed as Lisp data triple stating that “Peter has the disease heart-stroke”. and, hence, can itself be transformed by Lisp pro-
(add-triple !ins:Peter !ins:has-disease !ins:Heart-Stroke)
282 LANGUAGE-ORIENTED PROGRAMMING VIA DSL STACKING
4.4 Properties is expanded to: (add-instance !ins:Peter !ins:Person) Properties in RDF-S are defined via three triples, (add-triple !ins:Peter specifying the property itself, its domain and range. !ins:has-daily-duty !ins:Sales) Figure 3 shows an example. We have defined the (add-triple !ins:Peter !ins:has-income (value->upi 80000 :int)) macro add-property that allows programmers to ex- (add-triple !ins:Peter !ins:has-height press those three triples in a single, concise expres- (value->upi 175 :int)) sion: (add-triple !ins:Peter !ins:has-weight (value->upi 98 :int)) (add-property !ins:Person (add-statement !ins:Peter !ins:takes-drug !ins:has-disease !ins:Disease) !ins:Tobacco !ins:regularly) (add-triple !ins:Peter (add-triple !ins:Peter !ins:has-disease !ins:Heart-Stroke) !ins:relative-has-disease !ins:Heart-Stroke)
The RDF triple as a binary predicate is a simple yet Again, the notation has become more concise and powerful building block. However, in semantic mod- more comprehensible. eling often n-ary predicates are needed, with n ≥ 1. For this reason, we have extended the add-property macro to cope with different arities. See the follow- 5 DSL STACKING ing examples. (add-property !ins:Disease !ins:is-inheritable) (add-statement !ins:Heart-Stroke 5.1 Bootstrapping !ins:is-inheritable) The German author R. E. Raspe (1736-1794) has (add-property !ins:Person !ins:takes-drug written the wonderful tale of the impostor Baron !ins:Drug !ins:Frequency) Munchhausen.¨ Munchhausen¨ told his credulous au- (add-statement !ins:Peter !ins:takes-drug dience that he once got into a swamp and he started to !ins:Alcohol !ins:rarely) sink in. Quick-wittedly, he pulled himself out of the swamp by his hair or – in the less painful variation of The first example shows a unary predicate expressing the story – on his bootstraps. whether a disease is inheritable – here: heart stroke. Bootstrapping has since then become a metaphor The likelihood of suffering from a heart stroke is in- for self-sustaining processes of that kind. With our creased for people whose direct relatives have had Semantic Web DSL, we have done one kind of boot- a stroke. The predicate is implemented with range strapping. As the example in Sect 3.3 (ten lines of xs:Boolean. code for a simple triple) shows, RDF/XML is like a The second example shows a tertiary predicate ex- swamp for application developers. Instead of express- pressing the drug consumption behavior of a person – ing complex matters in the language of their business here that Peter drinks alcohol rarely. The predicate is domain, they sink into a mass of unnecessary, confus- implemented using RDF blank nodes. ing boilerplate code. By defining the DSLs in Sect. 4, So far, our DSLs contain general-purpose Seman- we have – step by step – pulled ourselves out of this tic Web extensions: parts, triples, classes, and pred- swamp: icates. In the following section, we add business- 1. Name spaces instead of full URIs domain specific extensions. 2. Concise triple notation 4.5 Business Domain Specific 3. Classes, subclasses and instances Extensions 4. Predicates of different arities 5. Business-domain specific extensions The following example At the end of the bootstrapping process, the appli- (add-insurance-statements !ins:Peter cation developer is able to express business logic in a :daily-duty :sales concise, comprehensible form. :income 80000 Analyzing the bootstrapping process shows that :height 175 we have applied the principle of stacking to our DSLs. :weight 98 DSL Stacking :drugs ’(:Tobacco :regularly) We call this method . :disease-of-relative :Heart-Stroke) Before specifying the method, we need to define a few concepts.
283 ICSOFT 2010 - 5th International Conference on Software and Data Technologies
Insurance DSL Stack with W3C Technology Stack Language Concept pose Semantic Web extensions for classes and predi- Semantic Web technology (Subset) cates. They provide semantics equivalent to RDF-S.
specific Top DSL Insurance Predicates In fact, they extend RDF-S insofar as they provide
Semantic Web DSL: classes, subclasses, instances, and predicates as lan- Predicates RDFS Intermediate DSLs Classes guage constructs whereas in RDFS one is constrained Triples Parts RDF to the lower-level triple notation. Again on top we
GPLs Common Lisp have implemented predicates that are specific to the insurance business domain. Base Language Lisp S-expressions XML general
Figure 4: DSL stacks. 5.3 The Language Stacking Method
5.2 Concepts We postulate the following requirements for the dif- ferent languages on the DSL stack before we define the language stacking method. In DSL stacking, we distinguish different kinds of languages, all of which are specified by syntax and Base Language. A base language should have a min- semantics. imalistic intrusive syntax and built-in bootstrap- ping features. • A base language is a language that allows the In Lisp, the S-expression syntax is minimalistic, specification and / or implementation of other lan- allowing for defining arbitrary concepts like data guages. Minimally, it must contain primitives like structures, control structures, and aspects of all numbers and characters and composition features kinds. like nested lists. Additional features include, e.g., name spaces. Base languages are usually self- Bootstrapping features allow the implementation describing, i.e., they can be specified in them- of new language constructs. In Lisp, these are the selves. Examples are: XML as the base lan- macro processor in combination with the fact that guage for all XML dialects like BPEL; MOF as code is represented as data. Other examples of the base language for UML, CORBA IDL etc.; bootstrapping features are the Meta-Object Proto- Lisp S-expressions as the base language for Com- col (MOP) in Groovy, or implicit conversions in mon Lisp as well as the Semantic Web DSL from Scala. Sect.4. Intermediate DSLs are those DSLs, in which the • A general purpose language (GPL) is program- application developer does not program directly, ming or specification language for a wide vari- i.e., which are not on top of the DSL stack. They ety of problems. Examples are C (Kernighan and should focus on a particular problem domain and Ritchie, 2008), Java (Gosling et al., 2005), or be simple yet expressive (Felleisen, 1990). The OMG’s UML. triple notation is an excellent example being ex- tremely simple yet allowing for implementing all • A domain-specific language (DSL) is a program- higher-level constructs like classes, subclasses, ming or specification language dedicated to a par- instances, and predicates. ticular problem domain. Examples are WS-BPEL Top DSL. The top DSL is the one in which the ap- (OASIS, 2007) or the DSLs from Sect.4. plication developer programs directly, i.e. the one • A DSL stack is a set of languages with based-on on top of the DSL stack. It should be most ad- dependencies. A language L1 is based on another equate for the application being developed: suf- language L2 if L1 is specified or implemented in ficiently expressive, concise and comprehensible L2. DSLs may be based on other DSLs, GPLs, or for the domain expert. on the base language. DSL stacking is a method for language developers to Figure 4 shows the DSL stack for the Semantic Web provide DSLs for application developers. It consists DSL from Sect. 4. Languages further up in the stack of the following steps. are based on the lower ones. As the base language we 1. Select a base language that meets the require- use Lisp S-expressions. This is analogous to XML ments specified above. as base language of the W3C Semantic Web Stack. On top of the base language, we use Common Lisp 2. If necessary, select a GPL implemented on top of as a GPL to implement DSLs for parts and for triples. the base language. They implement the semantics of RDF. On top of the 3. While the requirements for a top DSL are not yet base technologies, we have implemented general pur- met: select or develop DSLs on top of the stacked
284 LANGUAGE-ORIENTED PROGRAMMING VIA DSL STACKING
Integration, project-specific extensions (e.g., Insurance Predicates) Presentation Insurance Insurance Entity, queries, Customer Semantic Web Configuration Back-Office application data Workflow DSL GUI DSL Test DSL Dialogs DSL DSL Dialogs type DSLs GPL GUI DSL (Common Lisp)
Base Language Application (Lisp S-Expressions) Logic Insurance Issuing Workflow Figure 5: Language hierarchy. Workflow DSL Policy Issuing languages. Those languages must meet the re-
quirements for intermediate DSLs. Product Customer Rating Management Management
Entity, Query, Semantic Web Language stacking as a method is to be used by the Appl. Data Type, DSLs language developer. The application developer does DSLs not have to be aware of the DSL stack since he is Data Access Transaction Static Data Rules Data programming in the top DSL only. Whether or not Data Entity, Query, Appl. Data Type, the top DSL includes language features of lower-level DSLs languages is a matter of visibility. In internal DSLs, all lower-level language features are visible by de- Figure 6: Insurance example component architecture. fault. However, sometimes it is desirable to restrict language features by hiding lower-level DSLs, e.g., in which each component is implemented in one or for security reasons or in order to reduce the com- more DSLs. Insurance Back-Office and Customer Di- plexity for the application developer. alogs are implemented with the GUI DSL. The insur- ance issuing workflow is implemented in the work- 5.4 Integrating Multiple Languages flow DSL. Product Management, Customer Manage- ment and Policy Issueing are implemented in DSLs So far, we have considered a single stack of DSLs for Business Information Systems including applica- only. When building large applications like business tion data types, persistent entities and entity queries. information systems, different tasks require different The rating component is implemented in the Seman- kinds of DSLs. Stacking all languages on the same tic Web DSL described in Sect. 4. Finally, static data, base language allows to seamlessly integrate compo- transactional data and rules data are stored and re- nents implemented in different DSLs. This not only trieved via the persistent entity DSL. allows for invoking functions from any language to any other language at runtime. It also means inte- grated development: using the same editor, compiler, and test tools for different languages. Also – most 6 DISCUSSION importantly – integrated debugging of applications in different languages is possible. 6.1 Evaluation of Goals To demonstrate this, we have implemented or used a number of Lisp-based DSLs for business informa- We now evaluate the approach presented against the tion systems and have integrated them with the Se- criteria for developing high-quality solutions at rea- mantic Web DSL from Sect. 4 (see Figure 5). sonable cost set out in Sect. 1. • Application data types DSL, based on the Com- mon Lisp type system Sufficient Expressiveness. The Semantic Web DSL presented is based on the RDF/RDF-S technol- • Persistent entity DSL based on AllegroCache ogy and, hence, expose at least their expressive- • Entity query DSL based on AllegroCache ness. Together with a Prolog-based rules and • Workflow DSL based on Allegro Common Lisp query DSL, the insurance rating logic could be ex- Multiprocessing pressed directly. • GUI DSL: Allegro Common Graphics Conciseness and Comprehensibility. Statements • Test DSL: LispUnit should be expressed adequately, i.e., as concisely and comprehensibly as possible. Unnecessary • Configuration DSL: ASDF boilerplate code was avoided. We have compared We have, then, implemented a prototypical in- the code size of the insurance application im- surance application based on those languages. Fig- plemented in the Semantic Web DSL to the size ure 6 shows an UML component diagram of the ap- of the resulting N-triples code. We measured a plication. It is structured as a three-layer architecture saving of 74% in lines of code (one N-Triple part
285 ICSOFT 2010 - 5th International Conference on Software and Data Technologies
per line) respectively 77% in code size (number mantic Web language stacking. The designers of of characters including white space). This will the Semantic Web standards have, as a standardiza- result in considerable less implementation and tion body, to stop bootstrapping at a reasonable level maintenance cost. of generality. DSL stacking continues bootstrapping Not numerically measurable but obvious is the in- from there until the requirements for the top DSL are creased comprehensibility of the code – under- met, i.e., a most adequate language for the respective standable and maybe even editable by business problem domain is found. This allows to gain the full domain experts. This will result in higher qual- benefit of Language-Oriented Programming. ity of the solution. Integration. We have integrated the insurance com- ponents, all implemented in different DSLs, with 7 CONCLUSIONS each other to form a business information system. Invocations Dialog → Work f low → Rating → To conclude, we summarize the key statements of this Database did not require an additional middle- article. When you have a complex problem to solve ware. Editing, compiling, and testing was all per- you should proceed as follows. formed in one development environment (Alle- 1. Use a development environment that allows the gro CL Express Edition). Particularly, integrated design and implementation of DSLs. debugging of code implemented in different lan- guages was possible and most helpful. 2. For each subproblem, choose a DSL which is Performance. The Semantic Web DSL has been im- most appropriate: concise and comprehensible. plemented as Lisp macros which are expanded at 3. If such a DSL does not exist, develop one. compile time and, therefore, cause no runtime per- 4. Stack the DSL on top of a lower-level language. formance penalty whatsoever. The base language is the bottom of the stack. Efficient DSL Development. The code for imple- Language-Oriented Programming is neither new nor menting the Semantic Web DSL on top of Al- a silver bullet but it helps in the development of appli- legroGraph described in Sect. 4 is less than 100 cations with high quality at reasonable cost. For ap- lines of Lisp code (loc) including comments. The plications using XML-based Internet technology like total amount of code for all DSLs used in the in- Semantic Web standards, Language-Oriented pro- surance application as described in Sect. 5.4 is gramming is particularly useful – see also (Graunke less than 1,000 loc. Development and testing of et al., 2001). We have demonstrated the effectiveness all DSLs was an effort of less than a person month. by measurements of code savings of about three quar- This can be regarded as an efficient means of im- ters in an experimental implementation of an insur- plementing such a comprehensive set of DSLs. ance business information system. However, it shall be noted that the implementa- DSL stacking allows for cost-efficient realiza- tion is experimental and not production-ready. A tion of Language-Oriented Programming. We have major effort in production-ready DSL implemen- demonstrated this by implementing a complete Se- tations lies in the meaningful handling of compiler mantic Web DSL in less than 100 loc and by imple- errors, particularly if the DSL is to be used by menting DLSs for application data types, persistent non-programmers. entities, entity queries, workflow, GUI, test, and con- This demonstrates the validity of the approach in gen- figuration in less than 1000 loc. eral and the Semantic Web DSL in particular. Those convincing numbers are partially due to the prototypical character of the implementation and ex- 6.2 DSL Stacking isting powerful lower-level DSLs like Allegro Graph on which the new DSLs could be stacked. They are Language stacking is an application of the principle of also partially due to the fact that Lisp as an extensi- separation of concerns – like component-orientation ble language is particularly suitable for implementing and layered architectures. Different aspects are sep- internal DSLs. arated into several languages, like components in a A downside for applying Language-Oriented Pro- system. Different languages are built on top of each gramming and DSL stacking in large-scale industrial other with strict dependencies, like in a layered archi- projects is that extensible programming languages are tecture. currently not in mainstream use. This has a number of DSL stacking is a form of language stacking. consequences: the stock of programmers is limited, However, there is an important difference to the Se- development and production tools are less perfected.
286 LANGUAGE-ORIENTED PROGRAMMING VIA DSL STACKING
However, we notice a revival of extensible pro- with High-Level Programming Languages. In David gramming languages. Within the last decade, quite Sands, editor, Proceedings 10th European Symposium a number of such languages have been implemented on Programming (ESOP 2001), Genova, Italy, April 2001, volume 2028 of Lecture Notes in Computer Sci- on top of mainstream platforms and their number is ence. Springer. increasing rapidly. Examples are implementations of Greenfield, J. (2004). Software Factories: Assem- Python, Ruby, Groovy, and Scala on the Java Platform bling Applications with Patterns, Models, Frame- or F# on the .NET platform. Furthermore, there are a works, and Tools. http://msdn.microsoft.com/en- number of Lisp implementations on the Java platform, us/library/ms954811.aspx. e.g., ABCL, Clojure, Jatha, and CLForJava. Irons, E. T. (1961). A Syntax Directed Compiler for AL- What needs to be done? Professional tool support GOL 60. Communications of the ACM, 4(1):51–55. for Language-Oriented Programming and DSL stack- Irons, E. T. (1970). Experience with an Extensible Lan- ing, integration with mainstream platforms like Java guage. Communications of the ACM, 13(1):31–40. and the development of useful DSLs to be taken off Kay, A., Piumarta, I., Rose, K., Ingalls, D., and Amelang, the shelf. D. (2008). STEPS Toward The Reinvention of Pro- gramming: 2008 Progress Report Submitted to the National Science Foundation (NSF): VPRI Technical Report TR-2008-004. Technical report, Viewpoints REFERENCES Research Institute. Kay, A. C. (1993). The Early History of Smalltalk. In Aho, A. V., Kernighan, B. W., and Weinberger, P. J. (1988). HOPL Preprints, pages 69–95. The AWK Programming Language. Addison-Wesley. Kernighan, B. W. and Ritchie, D. M. (2008). The C pro- Berners-Lee, T., Hendler, J., and Lassila, O. (2001). gramming language. Prentice Hall PTR, Upper Sad- The Semantic Web: A new form of Web dle River, NJ, 2nd ed., 43. print. edition. content that is meaningful to computers will McCarthy, J. (1960). Recursive Functions of Symbolic Ex- unleash a revolution of new possibilities: pressions and Their Computation by Machine, Part I. www.scientificamerican.com/article.cfm?id=the- Communications of the ACM, 3(4):184–195. semantic-web. Scientific American. OASIS (2007). Web Services Business Process Ex- Brauer, J., Crasemann, C., and Krasemann, H. (2008). Auf ecution Language Version 2.0: OASIS Stan- dem Weg zu idealen Programmierwerkzeugen - Be- dard. http://docs.oasis-open.org/wsbpel/2.0/wsbpel- standsaufnahme und Ausblick. Informatik Spektrum, v2.0.pdf. 31(6):580–590. Simonyi, C., Christerson, M., and Clifford, S. (2006). Inten- Programming in Clocksin, W. F. and Mellish, C. (1987). tional software. In Tarr, P. L. and Cook, W. R., editors, Prolog, 3rd Edition. Springer. Proceedings of the 21th Annual ACM SIGPLAN Con- Dmitriev, S. (2005). Language Oriented Program- ference on Object-Oriented Programming, Systems, ming: The Next Programming Paradigm. Languages, and Applications (OOPSLA 2006), pages http://www.onboard.jetbrains.com/is1/articles/04/10/ 451–464. lop/. Steele, G. L. (1984). COMMON LISP: The Language. Digi- Feldman, S. I. (1979). Make — A Program for Maintaining tal Press, 12 Crosby Drive, Bedford, MA 01730, USA. Computer Programs. Software: Practice & Experi- van Deursen, A., Klint, P., and Visser, J. (2000). Domain- ence, 9:255–265. Specific Languages: An Annotated Bibliography. Felleisen, M. (1990). On the Expressive Power of Program- ACM SIGPLAN Notices, 35:26–36. ming Languages. In Jones, N., editor, Proceedings 3rd Ward, M. P. (1994). Language-Oriented Programming. European Symposium on Programming (ESOP’90) Software - Concepts and Tools, 15(4):147–161. Copenhagen, Denmark, May , 1990, volume 432 of Lecture Notes in Computer Science, pages 134–151, World Wide Web Consortium (W3C) (2010). Seman- Berlin, Heidelberg, Springer,. tic Web: http://www.w3.org/standards/semanticweb/, last visited 30/4/2010. Fowler, M. (2005). Language Workbenches: The Killer-App for Domain Specific Languages? http://martinfowler.com/articles/languageWorkbench. html. Goldfinger, R. (1961). Problem-oriented programming language structure. Communications of the ACM, 4(3):138. Gosling, J., Joy, B., Steele, G., and Bracha, G. (2005). The Java language specification. Addison-Wesley, Upper Saddle River, NJ, 3. ed., 1. print. edition. Graunke, P. T., Krishnamurthi, S., Van Der Hoeven, S., and Felleisen, M. (2001). Programming the Web
287