The MDD and DSL cracked, new era of software development is here

Replies to This Discussion

Permalink Reply by Kalle Launiala on February 7, 2011 at 21:35

I apologize the documentation being so lean, I haven't got time to write much longer.

 

The idea clears out best for people who can use visual XML schema designer (such as Altova's XML Spy) and are developing with Visual Studio, so that they can start exploring the model already.

 

The download section is also very "alpha"; this is because the majority of the work is done in actual customer controlled projects for now and we cannot share those abstractions publicly :(

 

I'm happy to fill in all what's left out in the documentation.

 

Kalle

• ▶ Reply

Permalink Reply by Andreas Leue on February 8, 2011 at 8:34

I guess the paragraph "Technology Proof" on page http://tinyurl.com/4cwa7qd describes the "technological core" of your approach? Could you explain this a little bit more?

Thanks, Andreas

 

• ▶ Reply

Permalink Reply by Kalle Launiala on February 8, 2011 at 8:39

Hello,

 

I tried to write it out on:

 

http://abstraction.codeplex.com/documentation

 

The basic idea at short is; the any given "structured block" of application that serves as a logical architectural block can be abstracted.

 

The Theory and Practice is here; I know it's also very tight written, opens better when using it in practice:

 

http://abstraction.codeplex.com/wikipage?title=Theory%20and%20Pract...

 

Visualizations there describe how an abstraction is made and how its then used, when its done.

 

The breakthrough differentiators are listed separately:

 

http://abstraction.codeplex.com/wikipage?title=Breakthrough%20Diffe...

 

 

I hope this helps.

 

I am sorry I have not had time to put much examples there, with VS + Altovas tool the process can be demonstrated with the download section "alpha" release source code.

 

Hope this at least partially answered your question

 

 

Kalle

• ▶ Reply

Permalink Reply by Kalle Launiala on March 7, 2011 at 20:24

We are soon uploading more content; of full scale examples of full abstraction stacks.

 

Currently we have one solid example video:

 

http://www.youtube.com/watch?v=rXuX0sIY3Ls

 

Now to point out, this trivialization requires only 35 lines of functional code on top of the full-scale architectural abstraction stack.

 

100% Code reuse, we'll be providing several different approaches for "commodizing the software development"; standard mobile user can start making applications soon from his/her own mobile phone device.

 

Kalle

• ▶ Reply

Permalink Reply by Kalle Launiala on June 14, 2011 at 20:33

We've included now full stack of general Command And Query Responsibility Separation + Event Sourcing architecture.

 

The demonstrations include full download, videos of platform-agnostic and raise of abstraction as the Android client effectively needs different platform-level interface compared to Windows Phone.

 

Current development is focusing to push smart phone development on primary schools (as simplified to maximum + integrated with Google's existing App Inventor) opens all kinds of possibilities.

 

I would like to underline, that simplification with "abstractions" is no compromise; the full-enterprise-grade CQRS + Event Sourcing will be serving the simple teenager's application just fine.

 

http://abstractiondev.wordpress.com/2011/06/10/googles-app-inventor...

 

Demonstrational videos:

http://www.youtube.com/view_play_list?p=B3366B17004D5DB9

 

General architecture case described:

http://abstractiondev.wordpress.com/case-study-cqrs/

 

 

Free to use, fully open source, based on standard and common Visual Studio + free 3rd party tools.

 

Enjoy!

 

Kalle

• ▶ Reply

Permalink Reply by Kalle Launiala on June 19, 2011 at 16:51

Hello,

 

Finally we released full downloadable source code and video demonstration of what I'll call "absolute trivialization". The writing capable person that understands basic logic can start making software.

 

http://abstractiondev.wordpress.com/2011/06/17/android-development-...

 

Released finally full demonstration of multi-level abstraction. Note the following:

 

Technology not only works well with "stacked" templating, but also there are no dependencies between the abstractions. The trivialization and full advanced CQRS architecture abstraction are completely unaware of each other. This means that combination of 1-n abstractions simply requires transformation support between each other. The complexity of the whole system stays at mathematical minimum.

 

Worth noting also:

- No external tool is required

- Architecture design is just standard XML

- Code generator is Visual Studio standard T4 (MonoDevelop as open-source free/non-Microsoft platform alternative)

- Code generator can be anything else as well as long as XML serialization is supported; T4 is just practical in Visual Studio as it's included and is Intellisense-enabled (by 3rd party free editor support)

- Learning curve is minimal; XML schema is common good-to-know for architects; the end-developers don't need to know that at all

- T4 learning curve is minimal for a code generator with C# experience; again - the end-developers don't need to understand that either

 

Compared to traditional HOW-TO and example/reference codes, properly made architectural abstraction is cheaper/faster to make and end-developer experience is optimal. For both simpliciy and productivity.

 

So all in all, this is simply a methodology of using existing standard tools. All our reference abstractions are fully open (because they have to be by the nature) and free to use.

 

We are starting to work shared reference-libraries on top of Git; we'll be requiring community effort to build the tools for now. Again, everything free and open-source.

 

Enjoy!

 

Kalle

• ▶ Reply

Permalink Reply by Kalle Launiala on September 26, 2011 at 18:19

We are preparing to demonstrate logical operation design, that provides a way to raise abstraction level from implementation to design level that applies universally everywhere.

 

This in short means logically pure way of raising the level of abstraction (that traditional DSL can only achieve if the language modification happens within the same version controlled changeset); when the compromise is removed, software design becomes much simpler.

 

This accompanied with full-scale-modularity (of abstraction blocks), that can also target other abstraction blocks (fully customizable within single source control check-in scope), means totally different level of reusability, as the platform/binary restrictions do not apply.

 

While this is soon due, for heads up we published following:

 

Specification, Requirements and Project Status Tracking; all derived from the abstraction level raised to the logical design-level:

http://abstractiondev.wordpress.com/2011/09/26/specifications-requi...

 

 

The whitepaper explaining the "next-paradigm" of mainstream software development; describing how simple controlled IDE-supported code-generation can outperform heavy-traditional-DSLs:

http://abstractiondev.wordpress.com/2011/08/26/whitepaper-draft-for...

 

For those interested, enjoy!

 

Kalle

• ▶ Reply