Chapter 1. What are domain-specific languages?
1.2. Understanding domain-specific languages
1.3. Distinguishing between DSL types
Chapter 2. An overview of the Boo language
2.2. Exploring compiler extensibility
2.4. Boo’s built-in language-oriented features
Chapter 3. The drive toward DSLs
3.1. Choosing the DSL type to build
3.2. Building different types of DSLs
3.4. Choosing between imperative and declarative DSLs
3.5. Taking a DSL apart—what makes it tick?
3.6. Combining domain-driven design and DSLs
3.7. Implementing the Scheduling DSL
4.1. Designing a system with DSLs
4.2. Creating the Message-Routing DSL
4.3. Creating the Authorization DSL
4.4. The “dark side” of using a DSL
Chapter 5. Integrating DSLs into your applications
5.1. Exploring DSL integration
5.3. Ordering the execution of scripts
5.4. Managing reuse and dependencies
5.5. Performance considerations when using a DSL
5.6. Segregating the DSL from the application
5.6.1. Building your own security infrastructure
5.6.3. Considerations for securing a DSL in your application
5.7.1. Handling runtime errors
Chapter 6. Advanced complier extensibility approaches
6.4.2. Building macros with the MacroMacro
Chapter 7. DSL infrastructure with Rhino DSL
7.1. Understanding a DSL infrastructure
7.2. The structure of Rhino DSL
7.3.1. ImplicitBaseClassCompilerStep
7.3.2. AutoReferenceFilesCompilerStep
7.4. Batch compilation and compilation caches
8.4. Integrating with a testing framework
9.1. Starting from a stable origin
9.2. Planning a DSL versioning story
9.2.1. Implications of modifying the DSL engine
9.2.2. Implications of modifying the DSL API and model
9.3. Building a regression test suite
9.4. Choosing a versioning strategy
9.4.3. Additive-change strategy
9.5. Applying versioning strategies
9.6. DSL versioning in the real world
Chapter 10. Creating a professional UI for a DSL
10.1. Creating an IDE for a DSL
10.2. Integrating an IDE with a DSL application
10.2.1. Extending #develop highlighting for our DSLs
10.2.2. Adding code completion to our DSL
10.2.3. Adding contextual code completion support for our DSL
10.3. Creating a graphical representation for a textual DSL
Chapter 11. DSLs and documentation
11.2. Writing the Getting Started Guide
11.3.1. Explain the domain and model
11.3.2. Document the language syntax
11.4. Creating the Developer Guide
11.4.1. Outline the prerequisites
11.4.2. Explore the DSL’s implementation
Chapter 12. DSL implementation challenges
12.1.1. Technical—managing large numbers of scripts
12.1.2. Performing precompilation
12.2. Deployment—strategies for editing DSL scripts in production
12.3. Ensuring system transparency
12.3.1. Introducing transparency to the Order-Processing DSL
12.3.2. Capturing the script filename
12.4. Changing runtime behavior based on AST information
12.5. Data mining your scripts
12.6. Creating DSLs that span multiple files
12.7. Creating DSLs that span multiple languages
12.8. Creating user-extensible languages
Chapter 13. A real-world DSL implementation
13.2. Designing the order-processing system
13.4. Moving from an acceptable to an excellent language
13.5. Implementing the language
13.5.1. Exploring the treatment of statement’s implementation
13.5.2. Implementing the upon and when keywords
Appendix A. Boo basic reference
A.2. The Boo interactive shell, interpreter, and compiler
Appendix B. Boo language syntax