Ask HN: Have you created a programming language and why?

In 1990 I started work at a tiny company run by people out of the mainframe data-processing world (apparently). Over the next year or so I created what was more or less Scheme with an infix syntax, plus a DSL for data formats. It happened gradually, starting with the DSL -- before that they'd write custom little programs in C to convert from a new client's format, etc. Then hey, why don't I hook up an arithmetic evaluator so we can filter records without another custom program? (They'd evaluated microcomputer database sytems as unsuitable.) And so on, until they had a real scripting language in a couple thousand lines of C. Nowadays you'd be kind of nuts to do this, but it was mostly a great success, and the gradual insinuation of this way of doing things was much easier to sell (from a guy right out of school) than bringing in a whole new language like Perl, if I could even be sure Perl would be right for them -- I'd just seen it listed in ads in Dr. Dobb's Journal. None of us were on the net. It was a different world.

The fun exception to the success was the time I tweaked something and broke the garbage collector, and we only found out when a job went back to the client with completely bogus results. An educational moment for me.

Years later at JPL I helped with a new Scheme dialect. It was partly in response to the politics described in "Lisp at JPL" https://news.ycombinator.com/item?id=2212211 -- we could say "this is actually a C program, see" -- but the language design was quite nice, IMHO. I can say that without backpatting because it was mostly done before I came in. Influenced by ML and Dylan; a shame it never was released.

I made one foray into language creation that some folks may find interesting, although I am very much an amateur. I designed a declarative language attempting to mimic the structure of human concepts. The idea was partly to try out this hypothesis that all concepts are reducible to 'types' and 'relations', and to try creating a language based on those two primitives. After coming up with some concept hierarchy, you could use it to generate particular instances of the root concept—the idea being to use it for procedural content generation. Here's some sample code:

  Chair: 
	(legs: Cylinder, seat: Slab, back: Slab)
	{
		attachment(legs, seat)
		attachment(seat, back)
	}

  TestType1:
	OriginType 
	(
		a: unsequence[x: Type2, xor[y: {Type3}(), z: type4]],
	 	b: optional[Fruit], c: >3[pet: Animal], d: 2[Animal(Blah){}]
	)
	{
		constraint1(x, y, z)->recognize->toInt
		constraint2(x, z.a.b.c)
		constraint3(z, y)
	}

I wrote a grammar for the language and generated a parser, and have a design for the runtime on paper—but, the design was rather complex and for various reasons I thought it would be best to build a general purpose data structure visualizer to assist in writing it. That ended up being a quite large project on its own, which I'm still working on (quick demo: https://www.youtube.com/watch?v=HpxgUVNAhXc ; more info: http://symbolflux.net/projects/avd).

I also realized recently that my main 'innovations' were already covered by the logic programming paradigm decades ago, so that has discouraged me some. (And I've recently started thinking that machine learning will be better for doing procedural content generation than anything produced by explicit descriptions.)

I once created an emulator for HP Time-Shared BASIC (https://en.m.wikipedia.org/wiki/HP_Time-Shared_BASIC) so I could run the original code for the original text-adventure form of Oregon Trail. I already had much of the AST parsing infrastructure in place for a syntax highlighting text editor I had written. The text editor component got extended to be the terminal emulator. This was all in JavaScript, rendering with Canvas2D, so that the resultant image could be textured into a 3D model of a Commodore PET (the only "old" computer model I could find that didn't cost an arm and a leg to download) in WebGL, then displayed in a VR headset through WebVR.

I regret nothing.

Sure. Email me.

I’ve been working on a statically typed concatenative programming language, Kitten[1], off and on for a few years now. I plan to do an early release this year.

I started working on the language to bring an elegant compositional style to low-level high-performance programming, in the form of a simple language that admits powerful tooling for program editing and visualisation. I also wanted to address usability concerns with stack-based languages (e.g., by allowing infix operators). As I’ve spent time in industry, I’ve begun to treat it as a way to address my gripes with C, C++, and Haskell; and as I’ve learned more type theory, I’ve begun to use it as a playground for type system research.

The goal is to allow pure functional programming that “feels imperative”, with a simple performance model (unboxed values by default, in-place updates, no laziness) and minimal runtime support (no GC, eventually no libc).

The latest compiler is nearly complete, but not yet usable for real programming. Still, you may like to keep an eye on its development.

[1]: https://github.com/evincarofautumn/kitten