Show and tell: “Language Engineer”

I am a software language engineer. But I call myself a language bender! What my super-power is? I am able to create domain-specific languages that can be used by others for reasoning about the world around them, to share ideas or to create new artifacts out of these persistable ideas. Artifacts like programs or diagrams or manuals.

Look at this article for example. I am its writer. But how was I able to make it? Well, I have a piece of software that supports me in this regard. Concretely, it is Notion at the moment — it could also be the Medium app or Apple Pages or Microsoft Word or or or… I can also use pen and paper for the same purpose but having a program has clear advantages:

• You can copy-paste and vary your text easily (Undo be praised!).
• You get tools for formatting and structuring your text.
• You even get tools for looking up synonyms, finding typos or grammatical issues.

Applications are written and designed the same way you can write an article or a book:

• Instead of creating a text that drives the human thoughts and imagination, the developer creates a text that drives the machine
• Instead of characters that drive the plot, the developer faces characters in the shape of variables, actors of a predefined role and content.
• Instead of pictures that illustrate the content of a paragraph, a developer is confronted with test suites to illustrate which parts of the program will not work when he publishs it.

A developer writes his programs in an editor, which is either text-only and without any guidance (doable but mostly a pain). Or he takes an integrated development environment (IDE) with support for his favorite programming language. These are called Microsoft Visual Studio, Apple Xcode or Eclipse (do not worry there are a lot more!).

An IDE helps you to write the program:

• it underlines variables when they are used before they are available
• it can warn you against undesired machine states
• it blocks you from creating programs that assign different roles (types) for the same variable
• it assists you to create tests to cover each line that was written for the actual program

An IDE is the writing program of a developer. And Microsoft Word is the IDE of a writer. They have the same two goals:

1. supporting and accelerating the author for finally…
2. publishing a deliverable artifact (a PDF or a program)

Well, Word, Pages or LibreOffice were written by developers to help authors to write and finally publish documents. And IDEs? They were written by language engineers to help developers to write and finally deliver programs.

“Writer programs were written by developers to help authors to write and finally publish documents”

“IDEs were written by language engineers to help developers to write and finally deliver programs”

The aspect of „language“ gets a bit lost here, because Word and other writer programs were also created with respect to writing in a specific language. But here is an important difference. Writer programs and IDEs are both aware of an input language, but the deliverable artifact that falls out at the end of the development process has a different purpose:

• Writer software is providing support for natural languages whose artifact communicates knowledge
• IDEs mostly are meant to support formal languages whose artifact is meant to communicate function

A writer program is not meant to have a clue about the content. It will not extract information from sentences. „What is the knowledge behind this sentence?“ It is out of scope! Analyzing natural language is a job for natural language engineers. Natural language engineers are needed for automation of information retrieval, chat bots, summarizing texts… Contrary to software language engineers who write important parts of an IDE. Do not get me wrong: Information retrieval could be used in writer programs to find gaps in the telling (I could imagine). But that is currently not what I associate with an average writer program.

As a software language engineer or language bender (hihi)…

• you are working with parser generators to shape the language
• you talk about types and concepts of a domain
• you find out what is a good sentence in a language and warn the IDE user about bugs, flaws or avoidable states
• you are empowering IDE users to talk in their favorite language

And that is only the first half of the profession! The second half starts with a valid model of a sentence and derives new artifacts from it:

• you have to find out whether the derived artifact is really the optimal solution for the users needs
• you can for example improve execution speed or space consumption during the start or the runtime of your program
• you can create a good layout for a visualization
• you need a plan for finding an order in which multiple artifacts need to be processed
• depending on the target you might need to create machine instructions for a real or artificial machine

Isn‘t this a cool ability?! 😀 And I am not the only one, there are more people able „to bend languages“ for creating IDEs or similar tooling. People like Federico Tomassetti or Meinte Boersma. Companies like my employer TypeFox or my initiative “Language Benders”. But it is a relatively small circle from my perspective. Fortunately, I like writing and explaining such topics. So, the idea has born to create learning material for starters in language engineering — pardon, language bending.

I hope you enjoyed the read! Until next time!