Index

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Previous Chapter

Appendix G. Polyglot development

List of Figures

Index

[A][B][C][D][E][F][G][H][I][J][K][L][M][N][O][P][Q][R][S][T][U][V][W][X][Y]

A

abstract syntax tree. See AST. accidental complexity, 2^nd ActiveRecord alternation common parser combinator type annotation, self-type Ant as DSL, 2^nd ANTLRWorks append architecting an external DSL arguments, named AspectJ AST, 2^nd, 5^th side effect of parsing and Xtext awk

B

backtracking parsers Backus Naur Form. See BNF. beans, refreshable beginning Scala DSL modeling noncritical functionality testing Java objects wrapper for Java objects BNF grammar bottom-up parser how they work LR(k) parser operator precedence parser shift-reduce SLR parser Bracha, Gilad brokerage. See financial brokerage. bubble words Builder pattern, 2^nd, 6^th, 8^th drawback expressive DSL use in Java uses a mutable builder business rules and DI modeling with a DSL types model. See also domain rules.

C

call-by-need Cascading Style Sheets. See CSS. chaining decorators in Ruby choosing DSL implementations composability learning curve with external DSLs reusing existing infrastructure right level of expressivity choosing the DSL language Client Order Processing common vocabulary Clojure DSL with macros Closure Coco/R combinators, 2^nd, 3^rd Command pattern, 2^nd Command-Query Separation pattern common patterns of internal DSL dynamic decorators using mixins explicit type constrants hierarchical structures using builders higher-order functions as generic abstractions implicit context and Smart APIs macros for compile-time code generation Ruby metaprogramming common vocabulary binding to implementation model need for setting up commonality and variabilities, 2^nd, 3^rd communication gap, during development compile time code generation. See compile-time metaprogramming. compile-time metaprogramming Blitz++ C++ templates and DSL how Lisp supports implementing syntactic macros Java support composability, 2^nd and concurrency and side effects with parser combinator. See also well-designed abstractions. conciseness concrete syntax trees const_missing context in a DSL context-sensitive validations control abstractions, 2^nd controlling metaprogramming with Groovy DSL CSS as DSL Cucumber as DSL

D

data structure data-as-code decorating a function in Clojure decorator Decorator pattern, 5^th, 6^th compose with domain abstraction improving the Java implementation in Ruby dependency injection. See DI. design patterns for composability developing a DSL using Xtext code for the semantic model metamodel for grammar development communication gap during distillation of the abstractions. See well-designed abstractions. domain analysis experts and DSL vs. modelers externalizing with XML domain modeling mapping problem domain into solution domain artifacts object for a Clojure DSL rules as DSL vocabulary, 2^nd. See also domain analysis. domain-specific language. See DSL. domain-specific types language interface of DSL DSL versioning patterns of implementation DSL workbench advantages main attributes variations DSL wrapper building the DSL publish Smart APIs sample domain model in Java DSL-based development tool support DSL-driven application architecture duck typing in DSL to implement polymorphism Scala dynamic code evaluation dynamic language DSL pitfalls dynamic typing concise DSL duck typing less accidental complexity of DSL metaprogramming succinct DSL syntax virtues

E

EBNF, 4^th, 5^th, 6^th grammar OrderParser.g follows notation Eclipse Modeling Framework. See EMF. Eclipse Xtext. See Xtext. Ecore metamodel, 2^nd EDSL embed scripting languages embedded, 3^rd. See also internal DSL. foreign code types. See Scala. embedded domain-specific languages. See EDSL. embedded DSLs patterns in metaprogramming, 2^nd patterns with typed abstractions. See also DSL, internal. EMF. See also Ecore. enhanced readability error reporting domain-driven errors and exceptions in DSL. See also handling errors and exceptions. exception reporting domain-driven execution model of a DSL with runtime metaprogramming expressivity limited, in DSL Extended Backus-Naur Form. See EBNF. extensible object system Scala extensible Visitor in Scala DSL extensible. See well-designed abstractions. external DSL abstracting the domain model anatomy embed Java code evolution of the semantic model integration patterns modularizing the steps parse & process parser generator populating the semantic model scaling up in complexity semantic model simplest form steps in processing using ANTLR external DSL design using parser combinators, 2^nd external DSL patterns classification context-driven string manipulation DSL design based on parser combinators DSL workbench mixing DSL with embedded foreign code transforming XML to consumable resource external DSL phases parse

F

F# financial brokerage system client order processing flatMap flexible syntax in Scala fluent interfaces, 2^nd, 5^th example of DSL final method of the chain for comprehension foreign embedding Fowler, Martin classifies DSLs fragile base class problem framework based integration. See Spring-based integration. function application common parser combinator type function threading Functional Java functional programming Scala

G

generative DSL runtime code generation, 2^nd global changes Google Collections Groovy-based DSL development environment setting up GroovyClassLoader GroovyShell groupBy combinator in Scala, 2nd generic implementation specialized implementation used in a DSL Guice, 2^nd

H

handling errors and exceptions Haskell Hibernate uses XML for entity description files higher-order functions homogeneous integration homoiconicity host language. See also internal DSL. HTML as DSL human interface

I

IDE plugin architecture idiomatic Clojure is a DSL immutable implementation of DSL, no need to know specialized to generalized implementation inheritance misuse implementation model binding to common vocabulary implementation patterns. See DSL implementation patterns. implicit conversions incidental complexity instance_eval instrument creation DSL IntelliJ IDEA Intentional Domain Workbench Intentional DSL Workbench interfaces fluent inheritance internal DSL common patterns embedded generative patterns summary typed abstractions vs. an API internal DSL patterns classification embedded generative integration metaprogramming compile-time reflective runtime Smart API syntax tree manipulation typed embedding

J

Java first implementation limitations no higher-order functions syntactic barriers syntax restrictions Java 6 scripting engine difficulty in debugging exceptions example in Groovy Groovy DSL integrating with application when to use Java Compiler Compiler. See JavaCC. Java EE Java Platform, Enterprise Edition. See Java EE. Java scripting. See Java 6 scripting engine. JavaCC JavaScript, 2^nd javax.script JetBrains Meta Programming System, 2^nd, 3^rd Jikes Parser Generator JRuby JSON JSR, 2^nd

K

keyword in Clojure

L

LALR lambdaJ language cacophony, avoiding. See DSL integration issues. language expressivity language syntax expressiveness vs. verbosity language-specific integration features left recursion LEX lexically scoped open classes Scala Lisp, 2^nd compile-time metaprogramming, 2^nd as the DSL macros work with ASTs metaprogramming patterns way of DSL design Lisp macros designing syntactic constructs for DSL how Lisp supports metaprogramming, 2^nd how they generate code little language LL(k) parsers generated by ANTLR LR parser variations

M

macros, 2^nd Make as DSL managing performance map metalinguistic abstraction meta-object protocol. See metaprogramming. metaprogramming, 18^th in Clojure DSL code generation compile-time macros and runtime vs. runtime controlling with Groovy DSL dynamic runtime behaviors expressive DSL Groovy metaprogramming inflection points in Groovy meta-object pitfalls reflective, 2^nd with builders Ruby basics in Ruby DSL runtime, 2^nd meta-object protocol. See dynamic typing; embedded DSL: patterns in meta-programming. method chaining. See also Builder pattern. method dispatch minimality of abstractions. See well-designed abstractions. mixins for extensibility modelers vs. domain experts modeling business rules with a DSL modular composition Scala monads and abstraction, 2^nd laws mutable and immutable builders

N

named and default arguments conciseness in Scala named arguments languages net settlement value. See NSV. NetBeans Newspeak noise index nonessential complexity nontextual DSL NSV main components

O

OCaml OOP pitfalls open classes operators as methods conciseness in Scala optional parenthesis conciseness in Scala order-processing DSL using ANTLR, 5^th custom actions grammar rules lexical analyzer order-processing DSL with parser combinators application combinators building the parse tree from parser to the semantic model grammar integrate semantic model with parsing process Order abstraction semantic model

P

packrat parsers in Scala backtracking call-by-need makes them efficient left recursion linear time parsing memoization ordered choice scannerless parsing semantic predicates PackratParsers features for DSL parse tree augment parsing syntax-directed translation patterns Builder, 2^nd, 3^rd, 4^th, 5^th, 6^th Command, 2^nd Command-Query Separation Decorator, 2^nd, 3^rd implementation interpreter matching Pimp My Library Visitor with typed abstractions. See DSL implementation patterns. Pimp My Library pattern pluggable domain rules polyglot development environment a Java-Groovy environment a Java-Scala environment features popular IDEs polyglotism problem domain entities of mapping components to solution domain programming mixin-based progression in DSL development Projection Editor projectional editor prototype. See prototype-based OO. prototype-based OO

Q

quality of abstraction

R

Rails. See Ruby. Rake as DSL RD parser. See recursive descent. read-eval-print-loop. See REPL. recursive descent parsers reflective metaprogramming, 2^nd repetition common parser combinator type REPL session with Clojure DSL RSpec as DSL Ruby, 19^th abstracting validation logic chaining decorators in defining classes and objects dynamic decorators dispatch method definition example DSL with metaprogramming feature overview flexible syntax interpreter DSL metaprogramming for concise DSL mixin-based programming mixins as decorators modules reflective metaprogramming runtime metaprogramming sample DSL in Rails supports open classes why good internal DSL choice Ruby block managing side effects, 2^nd Ruby DSL features runtime metaprogramming, 2^nd and DSL

S

sample business rule as Scala DSL Scala Scala abstract type members advanced type system alternation combinator symbol as DSL implementation language base abstractions case classes, 2^nd checklist for trade-creation DSL combinator orElse combinators for DSL concise surface syntax conciseness in domain abstractions DSL embedded layer wrapper explicit constraints on values and types, 2^nd expressive syntax features for internal DSL design for comprehension generic type parameters groupBy combinator in Scala higher-order functions, 2^nd, 3^rd, 4^th idioms implicits lexically scoped, 2nd mixin-based inheritance, 2^nd not lazy-by-default language object-functional packrat parsers parser combinator library partial functions, 2^nd pattern matching repetition combinator variations selective sequence combinator symbol self-type annotations, 2^nd sequence combinator symbol singleton objects notation static type checking statically typed DSL structural types traits in DSL type inferencing type safe combinator DSL typed abstractions Scala 101 Scala DSL wiring abstractions Scala packrat parsers. See packrat parsers in Scala. ScalaTest Scheme ScriptEngine, 2^nd scripting languages embed scripting. See Java 6 scripting engine. sed semicolon inference conciseness in Scala separating the DSL syntax from actions separation of concerns. See DSL integration issues. sequence common parser combinator type settlement, 2^nd date, definition standing instructions. See financial brokerage system. s-expressions instead of XML side effects and composability depend on past history and functional programming never compose side-effecting operations SLR smart domain APIs smart DSL on top of a legacy application, 2^nd software transactional memory solution domain Spring as DI framework config DSL for JRuby beans integration XML as external DSL SQL as DSL SSI standalone DSL. See DSL, external. static type checking. See Scala. subclassing confusing semantics subtyping, 2^nd syntactic sugar syntax-directed translation, 2^nd

T

Template Haskell trade-processing DSL in Ruby domain rules as decorators the DSL interpreter initial DSL API iterations monkey patching type inference conciseness in Scala typed abstractions. See Scala. types advantages compiler checks for consistency encapsulates business rules

U

V

value object variabilities. See commonality and variabilities. Visitor pattern vocabulary common. See common vocabulary.

W

what makes Lisp extensible code as data data as code simple parser why s-expressions semantically richer wiring abstractions in Scala DSL

X

XPath. See external DSL integration patterns. XQuery. See external DSL integration patterns. XText

Y

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.

3.15.147.215