Project Requirements: Domain Specific Languages — Fall, 2011

For this project, you will design, implement, evaluate, and document your own domain-specific language. This will be a significant effort on your part, and the project makes up 35% of your grade in this course. There will be periodic milestones during the semester, to help keep you on track and to provide you feedback as you work on your language.

Other than the deadlines and requirements described below, you have complete freedom. In particular, you're free to choose the domain and host language in which you will implement your DSL. You should choose a domain that really interests you and for which having a DSL would improve yours or others' programming productivity.

You may work either by yourself or with one other person. I recommend you work with someone else so that you can collaborate on language design.

The entire class also acts as a team. Several times this semester, every person or pair will discuss the current state of their project with the rest of the class. The class, in turn, will be asked to provide helpful feedback on your project.

• Weekly updates (5%) Every Monday @ 11:59pm Pacific, starting Monday, October 15.
• Choose a domain and partner, if applicable (5%) Monday, October 12 @ 11:59pm Pacific.
• Teaser (5%) Tuesday, October 16 & Thursday, October 18 @ 1:15pm Pacific.
• Project Plan (15%) Monday, November 5 @ 11:59pm Pacific.
• Design and Implementation Discussion (10%) Tuesday, November 6 & Thursday, November 8 @ 1:15pm Pacific.
• Demo / Presentation (10%) Tuesday, December 4, Thursday, December 6 & Tuesday, December 11 @ 1:15pm Pacific.
• Final code (25%) Friday, December 14 @ 11:59pm Pacific.
• Final write-up (25%) Friday, December 14 @ 11:59pm Pacific.

Edit your project's Wiki page to describe your progress for the previous week. Your description should be detailed enough to convey: (a) important descisions and progress you made over the week and (b) that the amount of time spent on the project over the week was ~10 hours per person.

When you have done so, create your project's Wiki page.

The goal of this assignment is to get the rest of the class excited about your project. You will give an in-class presentation that provides an overview of your project, as you understand it now. In particular, you should do the following:

• On your project's Wiki page, answer all the questions in the "Pitch" section. (Do this by Monday, October 15 @ 11:59pm Pacific)
• Sign up for a presentation slot. (Do this by Monday, October 15 @ 11:59pm Pacific)
• Create a presentation that describes all this information. The presentation should be no more than five minutes.

The nature of the presentation is for you to decide. Use any technique (e.g., slides, whiteboard, talking, pantomime) that you think is most effective to introduce your project to the rest of the class. The presentation should not just be a list of your answers to the questions on the Wiki. Rather, it should engage the audience in some way. You want the audience to help you throughout the project. How can you best use this time to enlist the class to help with your project?

Your teasers will be evaluated according to this rubric.

The project plan is a rough draft of your final write-up, with a focus on design. It should address the following concerns:

• Domain: Describe your domain and motivate the need for a DSL (i.e., how could domain-experts use and benefit from a DSL?)
• Language overview: Answer the following questions:
  • What is the basic computation that your language performs (i.e., what is the computational model)?
  • What's the current state of your syntax design? Provide a formal specification of any syntax you've designed, and discuss your design choices.
  • What are the basic data structures in your DSL? How does a the user create and manipulate data?
  • What are the basic control structures in your DSL? How does the user specify or manipulate control flow?
  • What kind(s) of input does a program in your DSL require? What kind(s) of output does a program produce?
  • Error handling: How might programs go wrong, and how might your language communicate those errors to the user?
  • Are there any other DSLs for this domain? If so, what are they, and how will your language compare to these other languages?
• Implementation plan: How do you plan to implement your language? In particular, what host language do you intend to use, and why is the host language well-suited for this project?
• Validation plan: How do you plan to validate your project? In particular, how will you test the code — both the individual components and the whole?
• Teamwork plan: If you are working in a pair, how do you plan to divide the labor? Note: Each team member must work on every aspect of the project, including design, implementation, evaluation, and documentation.

Commit a PDF of your project plan into your (group's) SVN directory by the November 5 deadline.

Sign up for a presentation slot. (Do this by Friday, November 2 @ 11:59pm Pacific)

You will present your project plan to the rest of the class, and discuss what implementation progress you have made. Note: This means that you will need to have made significant progress on your implementation by this point.

Your discussion should be 9 minutes long and should address the following areas:

• A brief reminder of the goals for your project (< 1 minute)
• An explanation of your design and implementation decisions so far (~5 minutes). These decisions include (but are not limited to):
• Your host language (and justification)
• Internal vs. external implementation (and justification)
• Syntax design decisions
• An overview of the architecture of your system.
• Specific question(s) for the audience (~3 minutes). Find a way to use the audience to further your project. For example, they could vote on syntactic choices or language features, or they could help you brainstorm ways to implement your syntax, etc.

Sign up for a presentation slot. (Do this by Friday, November 30 @ 11:59pm Pacific)

This is your chance to show off by giving a demo of your DSL for the class. In particular, we want to see:

1. Cool things that a programmer can do in your language (i.e., how are you easing domain experts' pain?). This is the "demo" part of the presentation: be sure to show us some example programs and their execution.
2. Crafty techniques you used to implement your language (e.g., is there a set of simple semantic building blocks that you composed, or did you try something unexpected to overcome challenges in syntax design, environment design, etc.?)
3. Interesting insights you had into language design and implementation (e.g., what did you think would be easy that wasn't, what did you think was difficult that wasn't, how would you advise other implementers of DSLs in your domain or otherwise, what would you do differently next time, what would you add/change if you had more time, etc.?).

Note: This means that, by the day of your demo, your implementation should be almost complete.

Your demo will have a 15 minute time limit, with a little bit of flex time for questions.

Your teasers will be evaluated according to this rubric. The emphasis will be on clarity and on the insights you provide us.

Your write-up should describe your domain, your language, and your design and implementation processes. Specifically, it should have the following format:

Note that your writeup should be clear, cohesive, and well-written. A list of bullets that addresses the following questions is not sufficient.

1. Introduction: Describe your domain and motivate the need for a DSL (i.e., how could domain-experts use and benefit from a DSL?)
2. Language Overview: Give a high-level overview of your language. Be sure to answer the following questions and note any changes from your project plan:
• How does a user write programs in your language (e.g., do they type in commands, use a visual/graphical tool, speak, etc.)?
• What is the basic computation that your language performs (i.e., what is the computational model)?
• What are the basic data structures in your DSL? How does a the user create and manipulate data?
• What are the basic control structures in your DSL? How does the user specify or manipulate control flow?
• What kind(s) of input does a program in your DSL require? What kind(s) of output does a program produce?
• Error handling: How can programs go wrong, and how does your language communicate those errors to the user?
• What tool support (e.g., error-checking, development environments) does your project provide?
• Are there any other DSLs for this domain? If so, what are they, and how does your language compare to these other languages?
3. Example program(s): Provide one or more examples that give the casual reader a good sense of your language. Include inputs and outputs. Think of this section as "Tutorial By Example".
4. Language Design: Describe and the syntax and semantics of your program. Justify the design choices you made. This section should answer the following questions:
• How does the syntax of your language help users write programmers more easily than the syntax of a general-purpose language?
• What are the semantic abstractions / building blocks of your DSL?
5. Language Implementation: Describe your implementation. In particular, answer the following questions:
   • What host language did you use (i.e., in what language did you implement your DSL)? Why did you choose this host language (i.e., why is it well-suited for your language design)?
   • Parsing: How does your DSL take a user program and turn it into something that can be executed? How do the data and control structures of your DSL connect to the underlying semantic model?
   • Execution: How did you implement the computational model? Describe the structure of your code and any special programming techniques you used to implement your language. In particular, how do the semantics of your host language differ from the semantics of your DSL?
6. Evaluation: Provide some analysis of the work you did. In particular:
   • What works well? What are you particularly pleased with?
   • What could be improved? For example, how could the user's experience be better? How might your implementation be simpler or more cohesive?
   • Where did you run into trouble and why? For example, did you come up with some syntax that you found difficult to implement, given your host language choice? Did you want to support multiple features, but you had trouble getting them to play well together?
   • If you worked as a pair, describe how you divided your labor.

Commit a PDF of your write-up to your (group's) SVN directory by the December 14 deadline.