The Hogg Blog : DSL

Turtle Graphics Update

Jason Hogg — Thu, 26 Nov 2009 01:43:00 GMT

It is that time of the year again – thanksgiving. So that of course means I need to update the version of Turtle Graphics that I posted a year ago to test out Oslo. Turtle Graphics was a Logo like programming language created in the early 1980's as a means of introducing novices and children to programming on the BBC Microcomputer. Turtle graphics helped introduce people to programming using a simple functional language that provided instant visual gratification allowing the user to move a triangular turtle across the screen using simple commands such as forward, backward, right turn and left turn....(read more)

SecPAL Parser Updated for VS2008 and F#1.9.6.16

Jason Hogg — Sun, 27 Sep 2009 01:27:00 GMT

I finally got around to updating the SecPAL Parser to run on the latest version of Visual Studio and F#. Development experience should be much cleaner now because F# is far better integrated into VS. If you run into any problems please post a note or drop me an email. For more information please see our SecPAL CodeBox Community Site.

A Graphical DSL for Describing SOA Applications

Jason Hogg — Wed, 28 Jan 2009 09:05:00 GMT

Last October we ran a SOA workshop in Redmond, with the goal being to have members of the MCS field, global practices and other customer facing organizations discuss scenarios and patterns that they see on a regular basis. Having run several of these workshops in the psat, one challenge that is hard to overcome is ensuring people describe their scenarios and solutions in a standard way.

Given the lack of a standard vocabulary for many (most?) domains within our industry this is obviously made more difficult. In an attempt to overcome this shortfall myself, Piyush Gupta and Sudarsan Srinivasan spent about a month decomposing a number of customer solutions into their constituent patterns - thus building a catalog of patterns that participants at our workshop could use when describing solutions to their scenarios. Where such patterns were already documented, we normalized on terms from sources such as Hohpe's Integration Patterns, SOA Patterns, Workflow Patterns, Patterns and Practices and IBM's dev center.

Even armed with a standard vocabulary, the next problem becomes how do you succinctly present complex system designs without requiring large numbers of UML objects. Christopher Alexander aluded to the solution to this problem through the use of a visual notation to accompany each pattern. So I searched around and found that Matthew Oskowis had created a nice little Visio template including icons for each of Gregor Hohpe's patterns. This helped us for about 50% of the patterns and so I extended it to include the additional patterns that we had identified.

When using this visual notation it became too difficult expecting everyone to recognize each of these icons, so I also extended each icon to include the pattern name. It makes the diagrams a little clumsy - but they are still quite readable. As you can see in the diagram below it is also obvious that these icons convey a lot of information in a small amount of space - more so than an equivalent UML model would for example.

The diagram below illustrates one such example, where a service agent is performing requestor side caching allowing configuration information to be retrieved from a central configuration service and cached. The Configuration Notification Service also allows the client (should it subscribe) to be notified of changes to this configuration.

For my presentation for tomorrow's SOA BP conference I will be walking through a number of scenarios using this SOA DSL, so figured I would first post it on the blog for people that are interested in using it. If you use it or extend it let me know how you go, or share your updates.

Oslo MGrammar Turtle Graphics for VS2008

Jason Hogg — Sat, 13 Dec 2008 04:16:00 GMT

My colleague Joshy Joseph reminded me that the MGrammar based Turtle Graphics parser that I posted here was for VS2010. I have attached a newer version of the solution that Joshy coverted to run in VS2008. I noticed that Doug Finke has also done the same thing whilst also creating a couple of additional samples as well. Take a look at his blog for more details...

Creating a Logo / Turtle Graphics Textual DSL using Oslo MGrammar

Jason Hogg — Wed, 26 Nov 2008 01:17:00 GMT

In the early 1980's a programming language called Turtle Graphics was used as a means of introducing novices to programming on the BBC Microcomputer. Turtle graphics, a graphical version of Logo, helped introduce people to programming using a simple functional language that provided instant visual gratification allowing the user to move a triangular turtle across the screen using simple commands such as forward, backward, right turn and left turn.

At PDC this year the Connected Systems team introduced a new language called "M" - which allows textual DSL's to be created. I will talk more about this language in future posts especially compared with the F# Lexer and Parser that we used to create our textual DSL for SecPAL, but first I wanted to create a programming language with which to learn Mg. I thought a version of Turtle Graphics would be fun - and interesting for anyone else interested in experimenting with or learning Mg.

The programming language I am liberally calling Logo (and the associated interpreter) are fairly simple - but I thought it would be fun for people to play with, especially those with children who are looking for new ways to introduce their kids to progamming. I did the bulk of the work specifying the grammar for this simple version of Logo on the flight back from LA to Seattle - which should give you a sense of how intuitive Mg is - and how productive the Intellipad authoring experience is.

Given that Thanksgiving is just two days away I figured it would be patriotic (odd coming from an Aussie/Kiwi/Pom hybrid) to show how simple it is for this language to draw the United States flag - a design which obviously would make significant use of loops and nested loops.

The screenshot above shows the output from this program. The complete logo program listing is also included below so you can see how complex objects can be created using a simple grammar comprising of just 5 commands:

    - Commands - Commands perform actions such as moving or rotating.
        Rotate n - Rotate 'n' degrees
        Draw n - Draw a line 'n' pixels long
        MoveAbs x, y - Move to an absolute position
        Move x,y - Move to a position relative to last move / draw command
    - Loops - Sets of instructions which are executde iteratively. Loops can be nested.
        Loop n { [Command] }*

I have attached the full source code for this so that you can play with this yourself. The source code is based on the PDC (October?) version of Oslo which you will have to first download from MSDN. The language could easily be extended to include color, line widths, other types of lines such as bezier curves etc - which should provide a good introduction for anyone interested. Post pointers if you do anything fun with this.

In addition to the formal grammar for my logo language (logo.mg) the .zip file also includes a WPF interpreter that interprets the parsed output of our logo programs and converts them into WPF Path Geometry syntax. There is also a simple editor that allows you to edit and run our Logo programs - providing a nice easy way to start teaching your children to program. Or for yourself to start modifying the language as described above.

Enjoy!!! And (to those in America) Happy Thanksgiving...

// Logo (and Mg) sample program
// Happy Thanksgiving!

// Move to top left
MoveAbs 25,25

// Draw five rows of stars
Loop 5
{
   // Draw ten columns of stars
   Loop 10
   {
   // Draw five points to make each star
   Loop 5
   {
         Rotate -54
         Draw 5
         Rotate 126
         Draw 5
   }
   Move 20 -1
   }
   Move -210,20
}

// Draw the lines next to the stars
MoveAbs 430,25
Rotate -90
Loop 5
{
   // Lines are 5 pixels high
   Loop 5
   {
      Draw 200
      Move 200,1
   }
   Move 0 15
}

// Draw the lower lines on the flag
MoveAbs 430,125
Loop 5
{
   // Lines are 5 pixels high
   Loop 5
   {
      Draw 410
      Move 410,1
   }
   Move 0,15
}

Language Oriented Programming

Jason Hogg — Fri, 20 Jun 2008 17:58:00 GMT

Chris Smith from the F# team has an awesome blog post on language oriented programming - and specifically LOP in F#. For those new to LOP Chris describes it as a style of programming that resembles a domain specific language - but is still valid in a general purpose programming language.

As we see more and more DSL's emerge - specifically in domains where visual models aren't adequate to sufficiently represent domain concepts - I believe we will see a huge movement toward LOP. For our Security Policy Language this was the case - leading us to the creation of our SecPAL Parser - which was also written in F#.

Anyone interested in DSL's should definitely read Chris' blog post...