[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]
abstract syntax tree.
See AST.
accidental complexity, 2nd
ActiveRecord
alternation
common parser combinator type
annotation, self-type
Ant
as DSL, 2nd
ANTLRWorks
append
architecting an external DSL
arguments, named
AspectJ
AST, 2nd, 5th
side effect of parsing
and Xtext
awk
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, 2nd, 6th, 8th
drawback
expressive DSL
use in Java
uses a mutable builder
business rules
and DI
modeling with a DSL
types model.
See also domain rules.
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, 2nd, 3rd
Command pattern, 2nd
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, 2nd, 3rd
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, 2nd
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, 2nd
controlling metaprogramming with Groovy DSL
CSS
as DSL
Cucumber
as DSL
data structure
data-as-code
decorating a function in Clojure
decorator
Decorator pattern, 5th, 6th
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, 2nd.
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
EBNF, 4th, 5th, 6th
grammar
OrderParser.g follows notation
Eclipse Modeling Framework.
See EMF.
Eclipse Xtext.
See Xtext.
Ecore
metamodel, 2nd
EDSL
embed scripting languages
embedded, 3rd.
See also internal DSL.
foreign code
types.
See Scala.
embedded domain-specific languages.
See EDSL.
embedded DSLs
patterns in metaprogramming, 2nd
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, 2nd
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#
financial brokerage system
client order processing
flatMap
flexible syntax
in Scala
fluent interfaces, 2nd, 5th
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
generative DSL
runtime code generation, 2nd
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, 2nd
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
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
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, 2nd
javax.script
JetBrains Meta Programming System, 2nd, 3rd
Jikes Parser Generator
JRuby
JSON
JSR, 2nd
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, 2nd
compile-time metaprogramming, 2nd
as the DSL
macros work with ASTs
metaprogramming patterns
way of DSL design
Lisp macros
designing syntactic constructs for DSL
how Lisp supports metaprogramming, 2nd
how they generate code
little language
LL(k) parsers
generated by ANTLR
LR parser
variations
macros, 2nd
Make
as DSL
managing performance
map
metalinguistic abstraction
meta-object protocol.
See metaprogramming.
metaprogramming, 18th
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, 2nd
with builders
Ruby basics
in Ruby DSL
runtime, 2nd
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, 2nd
laws
mutable and immutable builders
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
OCaml
OOP
pitfalls
open classes
operators as methods
conciseness in Scala
optional parenthesis
conciseness in Scala
order-processing DSL using ANTLR, 5th
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
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, 2nd, 3rd, 4th, 5th, 6th
Command, 2nd
Command-Query Separation
Decorator, 2nd, 3rd
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
Rails.
See Ruby.
Rake
as DSL
RD parser.
See recursive descent.
read-eval-print-loop.
See REPL.
recursive descent parsers
reflective metaprogramming, 2nd
repetition
common parser combinator type
REPL session with Clojure DSL
RSpec
as DSL
Ruby, 19th
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, 2nd
Ruby DSL features
runtime metaprogramming, 2nd
and DSL
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, 2nd
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, 2nd
expressive syntax
features for internal DSL design
for comprehension
generic type parameters
groupBy combinator
in Scala
higher-order functions, 2nd, 3rd, 4th
idioms
implicits
lexically scoped, 2nd
mixin-based inheritance, 2nd
not lazy-by-default language
object-functional
packrat parsers
parser combinator library
partial functions, 2nd
pattern matching
repetition combinator variations
selective sequence combinator symbol
self-type annotations, 2nd
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, 2nd
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, 2nd
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, 2nd
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, 2nd
syntactic sugar
syntax-directed translation, 2nd
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
value object
variabilities.
See commonality and variabilities.
Visitor pattern
vocabulary
common.
See common vocabulary.
what makes Lisp extensible
code as data
data as code
simple parser
why s-expressions
semantically richer
wiring abstractions in Scala DSL
XPath.
See external DSL integration patterns.
XQuery.
See external DSL integration patterns.
XText
18.119.235.79