The document discusses generating business applications through executable models that separate business logic from technological choices. It highlights the importance of understanding the target platform and selecting the appropriate generator language, along with testing and reusing generators effectively. Additionally, it mentions ongoing development of a Java EE generator and the Alpha status of the Cloudfier tool.

1. Generating Business
Applications from
Executable Models
Rafael Chaves (@abstratt)
rafael@abstratt.com
http://abstratt.com

2. Motivation

3. Business applications
Domain knowledge
+
Applied technology

4. How it should be...

5. Domain knowledge
Memory
management
Persistence
CachingTransactions
Serialization
Concurrency
Integration
Communication
protocols
Security
Programming
language

6. How it usually goes...

7. Domain knowledge
Memory
management
Persistence
CachingTransactions
Serialization
Concurrency
Integration
Communication
protocols
Security
Programming
language

8. Executable models to the rescue

9. Executable models are
models but...
Precise
(as much as needed)
Complete
(about what matters)

10. Executable models are
programs but...
Focused
(on problem domain concepts)
Oblivious
(regarding technological choices)

11. Executable models promote a
complete separation between
business and technology

12. Persistence
Querying
Authorization
REST API
Text search
Integration
User interface
Logging
Authentication
Backups
Scaling
Email notifications
Usage-based billing
Payment processing
Prog. language
Entities
Relationships
Constraints
Operations and queries
States
Events
Services
Roles
Architecture
(applied automatically
by platform or code
generator)
Domain knowledge
(synthesized by programmer)

13. Demonstration

14. Tools
● vanilla UML as executable modeling language
○ extended via profiles/conventions
● TextUML - textual notation over UML
● Eclipse Xtend - for implementing generators
● Cloudfier - web-based modeling IDE with
interpreter/generators
General concepts > Particular tools

15. Modeling

16. Test-driven modeling

17. User-driven validation

18. Code generation

19. Structure-based generation
Classes
Attributes
Operations (signatures)
Associations
Other classifiers (enumerations, signals etc)
Default values/derivations

32. State machine-based generation
States
Transitions
Triggers
Guards
Entry/exit/do activities

43. Activity-based generation
Activities
Actions
Input and output pins
Object flows

45. Available actions
● read/write variable
● create/destroy object
● read self ("this")
● read/write attribute
● create/destroy link
● call operation
● structured node (blocks)
● test identity
● conditional (if/switch)
● loop (for/while)
● raise exception
● send signal

46. operation deposit(depositedAmount : Decimal) {
this.balance = this.balance + depositedAmount;
}

47. Plain Java
Plain Javascript

52. Lessons learned

53. Knowing the target platform matters
● Better to know what the destination looks
like before you start
● At a minimum, have fully-functional
handwritten example code

54. Pick your generator language wisely
● Java
○ full power, but awkward with collections (improved in
1.8), no string interpolation
● StringTemplate
○ standalone templates, but less control
● Groovy
○ graph navigation/transformation, string interpolation
● Xtend
○ plus static type checking, IDE support

55. Testing the generator
● have sample applications covering all
modeling language features
○ use a compiler/lint to check for syntactical errors
● have tests in your sample apps
○ generate then run tests to detect runtime/integration
problems

56. Generator Reuse
● within a platform (Plain Java, JPA-enabled)
○ share base templates, differ on details
● across target platforms
○ reasoning about models is often the same
● design reuse helps too
○ second generator is much easier

57. References
Blog
http://abstratt.com/blog/
Executable UML
http://www.executableumlbook.com/
http://www.omg.org/spec/FUML/
http://www.omg.org/spec/ALF/
Cloudfier/TextUML
http://doc.cloudfier.com - http://github.com/abstratt/cloudfier
http://abstratt.com/textuml

58. Status
● JavaEE generator under active development
(open-source EPL) (dev. started on Feb. 18)
● MEAN generator in the back burner
● Looking for sponsors / contracts to further
develop the generators
● Cloudfier is still alpha, you are welcome to try it

59. +1 0 -1
Sign in: www.eclipsecon.org
Evaluate the sessions

60. Generating Business
Applications from
Executable Models
Rafael Chaves (@abstratt)
rafael@abstratt.com
http://abstratt.com