14
\$\begingroup\$

I'd like to get some feedback on a small tuple-rewriting language I've been playing with. It has a working interpreter, and a working test case.

A little more background information: This idea began as an experimental "toy language," but as I worked on it, I realized it could be useful as a "real" DSL for the very specific task of authoring interactive fiction (you know, those ancient 1980s games like Zork and Hitchiker's Guide to the Galaxy). This is because it can be written in a relatively free-form way, and ends up closely resembling natural language. I was able to create a working version of cloak of darkness in the language.

I noticed this topic has been discussed here before, more than once, but I think this question is a bit different in that it's specifically about a language with a working implementation and a working test case.

  • I'm not asking for a design-only review; I'd value reviews of the specific implementation as well as the design.

  • Beyond that, it would be great to have the test case reviewed. Obviously nobody will be familiar with the language, but it's very easy to grasp, and it's based on familiar concepts (think string rewriting languages, except with tuples instead of strings, using trial-end-error binding of free variables, like some FP languages).

  • I feel like the language could be greatly enhanced with some small modifications, but have not quite decided how they should be implemented. I'd love to bounce some of these ideas around for feedback.

Is this sort of thing appropriate for Code Review? If not, is there another site on (or off) this network that might be a good fit?

\$\endgroup\$
  • \$\begingroup\$ Does the language have a clear specification? \$\endgroup\$ – Mast Jul 12 at 9:41
  • 1
    \$\begingroup\$ @Mast I'd write one up as part of the question. It's a very minimal language; think Thue, but with tuples (words separated by spaces) instead of strings, multipart rules allowing "wildcard" free variables, and simple top-down rule precedence, and you're probably 90% of the way there. I think a spec wouldn't be much trouble to write or digest. \$\endgroup\$ – user11536834 Jul 12 at 10:18
  • \$\begingroup\$ It may not be much trouble, but it's important such a thing is written before the language-implementation can be reviewed. \$\endgroup\$ – Mast Jul 12 at 11:50
  • \$\begingroup\$ You might check out codereview.stackexchange.com/questions/224306/… of my own posting, which is about a DSL I programmed, and includes its spec, but the review is on the implementation, following the A. below. \$\endgroup\$ – D. Ben Knoble Jul 17 at 16:16
5
\$\begingroup\$

To keep it simple the following are allowed:

  • Your own language - only if we can run it, so you'd need to provide the interpreter/compiler.
  • "reviews of the specific implementation"
  • "test case reviewed" - if you mean unit tests or similar tests and a working program, rather than an example program that highlights the languages features independently.
  • Asking for a review of the interpreter/compiler is allowed too.

This leaves these two parts as potentially dubious:

  • "I'd love to bounce some of these ideas around for feedback."

    Unfortunately the Stack Exchange network is designed for questions and answers. Whilst there is a comment section these normally aren't for additional questions, and people may tell you to go ask a new question instead.

  • A review of your language design.

    For the most part you can ask about anything in a question, but that doesn't mean you'll get an answer to it. This is as Code Review is only about giving ideas we think would improve your code.

    And so if you're happy that this could be ignored, and you get a normal code review then I wouldn't close your question because of this question. As it follows our any and all guidelines.

This is potentially off-topic:

  • "some small modifications, but have not quite decided how they should be implemented."

    This is off-topic if you have an idea you want us to add to your language. This is as your program wouldn't be working the way you intend it to - which is one of our close reasons.

    However these ideas can come up in a normal review. But they rare and normally are in regard to changing code and features you have to be easier to maintain. So may not be what you want.


To make sure no-one has any reason to close your question, as you've described, then remove the potentially off-topic aspect and the dubious parts.

\$\endgroup\$
  • \$\begingroup\$ Thanks for the reply; I think we're mostly on the same page. WRT that last bullet point: It's not a matter of not knowing how to implement a particular thing, but rather not having a clear idea of exactly what thing to implement. Imagine Prolog without that handy [Head|Tail] construction... you could still get stuff done, but it would be more cumbersome. I feel like something like that would make the language much more powerful, but that exact construction wouldn't quite fit in the language. I'd like to get ideas for an elegant way to work something like that in (for example). \$\endgroup\$ – user11536834 Jul 15 at 5:19
  • \$\begingroup\$ If you just want to bounce ideas off people, you can visit the main site chatroom. \$\endgroup\$ – 23fc9a62-56de-47fb-97b4-737890 Jul 20 at 0:14

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .