►Hack Your Own Language
▼Assignments
►2 Embedded DSLs A
On this page:
Part 1:   Implement an animation DSL in Java
Deliverable 1:   A working DSLExample  Animation
Deliverable 2:   Create your own animation in the DSL
Deliverable 3 for extra credit:   Extend the DSL with a new feature
Part 2:   Design the API for an embedded DSL in Racket
Submission
8.14
    contents    up   

2 Embedded DSLs A🔗

Due: Tuesday, January 14, 11:59pm.

Part 1: Implement an animation DSL in Java🔗

In lecture I presented an embedded DSL for animations in Racket: animation-dsl.rkt.

Your job is to translate this implementation to Java, and adapt the embedding to the different language features available in Java.

Download the starter code from here: part1-starter.zip.

The Racket version of the DSL uses the 2htdp/image and 2htdp/universe libraries. In Java you will use the javalib library from the Fundamentals II course, which provides a similar API adapted to Java: https://course.ccs.neu.edu/cs2510a/image-doc.html.

The library is already included and configured as a dependency in the starter code’s Gradle build file.

The starter code includes:

You should be able to run the main method of the provided ExampleAnimation file.

Your job is to complete the AnimationBuilder and supporting classes. For each way of constructing and composing animations in the builder like simple and sequence, you’ll need a corresponding class that implements the Animation interface. In order to implement the play method of the builder, you’ll need an AnimationRunner class that extends World from the javalib library. Examining the ExampleAnimation should give you a good idea of how to work with the javalib API.

Deliverable 1: A working DSLExampleAnimation🔗

Once you’ve implemented the DSL, you should be able to run the DSLExampleAnimation and get the same result as running the ExampleAnimation. Make sure to leave the DSLExampleAnimation class as-is, so that we can run tests against it.

Deliverable 2: Create your own animation in the DSL🔗

Create an animation of your own invention that takes advantage of the DSL. Deliver your animation as a new class with a main method that runs the animation. Document the name of this class in a README.md file at the root of the project.

Deliverable 3 for extra credit: Extend the DSL with a new feature🔗

For a chance at the coveted "OK++" grade, add an interesting new feature (or more than one) to the DSL and use it in the animation of Deliverable 2. Tell us about the new feature in README.md.

Part 2: Design the API for an embedded DSL in Racket🔗

These CSV files contain data about the authors and articles written for a (quite hypothetical) website about databases: authors.csv, articles.csv.

A convenient way to represent such data in a Racket program might be as a list of hash values, where each hash has keys corresponding to the column names in the CSV files.

In case you want to test out this data representation, here’s a function that can load into this format using the csv-reading library:

> (require csv-reading)
; A Table is a
; (ListOf (HashOf Symbol Any))
; Path -> Table

 

(define (load-table path)
  (with-input-from-file path
    (lambda () (csv-list->table (csv->list (current-input-port))))))

 

; (Cons (Listof Symbol) (Listof Data)) -> Table

 

(define (csv-list->table lst)
  (define column-names (first lst))
  (define row-lists (rest lst))
  (for/list ([row-list row-lists])
    (for/hash ([column-name column-names]
               [data row-list])
      (values column-name data))))

 

> (load-table "authors.csv")

'(#hash(("id" . "1") ("name" . "Alice Smith"))

  #hash(("id" . "2") ("name" . "Bob Johnson"))

  #hash(("id" . "3") ("name" . "Charlie Lee"))

  #hash(("id" . "4") ("name" . "Diana Evans"))

  #hash(("id" . "5") ("name" . "Ethan Wright"))

  #hash(("id" . "6") ("name" . "Fiona Brown"))

  #hash(("id" . "7") ("name" . "George Clark"))

  #hash(("id" . "8") ("name" . "Hannah Adams"))

  #hash(("id" . "9") ("name" . "Ian Turner"))

  #hash(("id" . "10") ("name" . "Jane Cooper")))

Querying with conventional Racket code

Now, consider the task of listing the article titles of all articles written by the author Fiona Brown. The articles table uses user IDs to refer to authors, so we must first find the user ID of Fiona Brown in the authors table, then filter the articles table to find the articles written by that user.

If we use conventional Racket code, one way to solve this task would be to write the following:

(define (find-user-id authors-table author-name)
  (for/first ([author authors-table]
              #:when (equal? (hash-ref author "name") author-name))
    (hash-ref author "id")))
 
(define (find-articles-by-author-id articles-table author-id)
  (for/list ([article articles-table]
             #:when (equal? (hash-ref article "author-id") author-id))
    (hash-ref article "title")))
 
(define authors-table (load-table "authors.csv"))
(define articles-table (load-table "articles.csv"))

 

> (find-articles-by-author-id articles-table (find-user-id authors-table "Fiona Brown"))

'("Joins Explained" "Data Normalization")

However, with a DSL the task could be much simpler.

Querying with SQL

In SQL, this task would be expressed as:

SELECT title FROM articles

JOIN authors ON articles.author_id = authors.id

WHERE authors.name = 'Fiona Brown';

An SQL-like DSL for querying Racket data

Beginning with this homework, we will design an embedded DSL in Racket that allows us to query data in the table format described above (lists of hashes) using SQL-like language constructs.

Your task in this assignment is to propose an API for the basic constructs of this DSL. Because we will implement this DSL by embedding (as opposed to extension), the API design will consist of data definitions and function headers and signatures. Write these definitions in the style you learned in Fundamentals I.

Your DSL should include operations to:

You should also express the same query as the SQL example above using your DSL (it doesn’t have to run at this point).

As you think through the example, you may have to make design choices or introduce extra operators not mentioned above. As part of your solution, document the issue and the design decision you made.

Submission🔗

Submit to Gradescope, in a group submission with your partner: https://www.gradescope.com/courses/941020/assignments/5541610

For Part 1: Implement an animation DSL in Java, upload a zip file called "part1.zip" containing the project, keeping the structure from the starter code and including your README.md.

For Part 2: Design the API for an embedded DSL in Racket, upload a file called "part2.rkt" containing the API design for your DSL and your expression of the query on articles and authors using the DSL API you propose.

    contents    up