Dale – A Lisp-flavoured C

Additionally, my comment was not directed solely at Dale, but new language announcements in general.

Steps: 1. Create a new language in which the problem is trivially expressed. 2. Solve the problem in the new language.

Lisp / Scheme are ideal for this.

Example: solve some sort of puzzle game. Create a data structure that represents the board, a game piece and a move. Operators upon these. Given a board and a legal move, return a new board with the move applied. Given a board, give all of the possible legal moves (for a particular player if this a multi-player game instead of a puzzle).

Once you have that language it becomes easy to use your favorite off the shelf search algorithms. Depth first. Breadth first. A*. Etc.

But, this is probably not the same reason to create a "language" as the article. And the notion of "language" is quite different.

Like look at this fragment from https://github.com/tomhrr/dale/blob/master/src/dale/Function...

  bool
  isUnoverloadedMacro(Units *units, const char *name,
                      std::vector<Node*> *lst,
                      Function **macro_to_call)
  {
      std::map<std::string, std::vector<Function *> *>::iterator
          iter;
      Function *fn = NULL;
      for (std::vector<NSNode *>::reverse_iterator
              rb = units->top()->ctx->used_ns_nodes.rbegin(),
              re = units->top()->ctx->used_ns_nodes.rend();
              rb != re;
              ++rb) {
          iter = (*rb)->ns->functions.find(name);
          if (iter != (*rb)->ns->functions.end()) {
              fn = (*iter->second)[0];
              break;
          }
      }

Name represented as char * ? I stopped using C strings in C++ code around 1998, other than in low level code interfacing with things that require them. Kids that were born then are now in college. If you're doing Lisp manipulation, you want anything that is a "name" of some kind to be an interned symbol, which quickly compares to another symbol variable as a pointer.

Why would you do all this to yourself, if (or so it seems) you know enough about Lisp to want a C-like language in S-exp syntax?!

From the CLASP page:

> Clasp is a new Common Lisp implementation that seamlessly interoperates with C++ libraries and programs using LLVM for compilation to native code. This allows Clasp to take advantage of a vast array of preexisting libraries and programs, such as out of the scientific computing ecosystem. Embedding them in a Common Lisp environment allows you to make use of rapid prototyping, incremental development, and other capabilities that make it a powerful language.

you wrote:

> This project uses LLVM's API, which is sadly difficult to utilize outside of C++.

I would guess that you could use LLVM's API via CLASP. The author initially wrote ( https://drmeister.wordpress.com/2014/09/18/announcing-clasp/) :

> Clasp exposes the LLVM C++ library within Common Lisp providing a rich, dynamic, programming environment for exploring the LLVM library and for writing new compilers that generate LLVM-IR.

Then you could write the parser/compiler in Lisp, which supports manipulating s-expressions on a simpler level than C++ does.