[Announcement] XtendFlow – example of an internal DSL realized with Xtend
Denis Kuniß
I would like to announce the Xtend library XtendFlow.
The main advantage of Xtend regarding internal DSLs is the fact that it is statically typed. AFAIK, on the JVM only Scala provides similar capabilities. I'm going to take advantage of that with XtendFlow.
I would like to share my solution in this group as a suitable example how well Xtend is applicable for internal DSLs and how to realize them. The implementation heavily relies on active annotations provided by Xtend.
However, the semantic of XtendFlow itself may be worth a closer look. It is a library for applying the Flow Design approach by Ralf Westphal in Xtend which allows to decouple functional components in a way not seen before making software designs evolvable. It shows a way out from the dependency hell quite often resulting from object oriented design. Flow Design is also the natural way for designing IODA architectures which tries to resolve the problems related to todays common architecture approaches.
Both, the method of Flow Design and the IODA architecture approach, in my opinion matches or complements quite well current change drivers for software engineering practices like event-driven architecture, event-based programming or reactive design and maybe goes beyond...
Looking forward for your comments.
Denis
P.S. Who understands German may also read my blog articles about XtendFlow and ScalaFlow – a similar library for Scala.
Christian Vogel
Adrian Sampaleanu
Do you intend to evolve XtendFlow into a full Flow Based Programming implementation?
-- Adrian
Adrian Sampaleanu
Denis Kuniß
yes, I made already a first try with Xtext based on Xbase, but currently I'm waiting on Xtext 2.9 being released. My hope is - with the new grammar inheritance improvements described by Sebastian Zarnekow - I may inherit directly from Xtend grammar and semantics adding Flow related language elements alongside the object oriented and functional ones in Xtend.
Furthermore, I'm currently working on getting my Flow DSL for/in Scala completed. This implementation was my starting point for Flow DSLs some years ago. However, when I got XtendFlow polished for the internal DSL I realized I could do a lot more in Scala too regarding the Flow DSL.
Of course, any help would be appreciated to push it forward to a "real language". I really think, the Flow-Design approach and the IODA architecture is worth a general-purpose language implementation with corresponding language concepts reflecting those concepts. ... And Xtext seems the right candidate for that, implementing an experimental first try (Thanks to the great work of the Xtext team!).
Regards, Denis
Adrian Sampaleanu
Denis, so just to be clear, when you speak of a flow design in your implementation, do you mean in the sense of FBP as defined by J Paul Morrison at http://www.jpaulmorrison.com/fbp ?
"FBP is a particular form of dataflow programming based on bounded buffers, information packets with defined lifetimes, named ports, and separate definition of connections.", as detailed on Wikipedia.
Cheers
Denis Kuniß
After superficial read, my first impression is that the notation is very close to my notation (must be a deeper truth there ;-)). However, the runtime semantics seems slightly different. FBP seems to require the concept of processes (or at least actors in sense of Erlang/Scala). Our approach is independent of such execution semantics (and in that sense more general). The only execution semantic is the method call semantic for data forwarding from port to port (no bounded buffers semantic; however, it may be added as an implementation inside a function unit; as well as actor semantics) .
In fact, my library is closely based on the work of Ralf Westphal. He described in this article also what is different to Paul Morrisons approach.
What really is different and new in my view is the underlying concept of IODA architecture where you only have [I]ntegrations containing connections logic only, [O]perations containing functional logic (the only place for control structures), [D]ata flowing around and [A]PI for connecting to foreign logic needed for the designed system (e.g., OS API).
Denis