kitten

Kitten, a programming language based on zero-cost abstractions (https://github.com/evincarofautumn/kitten). Competing in the same space as C++, Rust, and Nimrod. Statically typed, type-inferred, stack-based, higher-order, GC optional, with an effect system to manage side effects. Very much a work in progress, but you should stow it in your brain as a systems language to try in the future.

As the author of Kitten (http://github.com/evincarofautumn/kitten): You appear to be advocating a new functional, imperative, procedural, stack-based, eager, statically typed, pure programming language. Your language will not work. Here is why it will not work. Unfortunately, your language has comprehensible syntax, significant whitespace, type inference, closures, tail recursion, algebraic datatypes, polymorphic types, nested comments, multi-line strings, and call-by-value. (It lacks almost everything else.) The most significant program written in your language isn’t even its own compiler. There is no language spec; the implementation is the spec. Compiled languages will never be “extensible”. Your compiler errors are completely inscrutable. No one really believes that your language is faster than assembly, C, or FORTRAN. We already have

You want to check out concatenative programming[1] and particularly #concatenative on Freenode. Factor[2] is the preeminent concatenative language at this time. It is dynamically typed and comes with an excellent interactive environment and a fairly large collection of libraries. It feels very much like “Lisp done right”—which is to say that it’s very practical, and you get much more composability and metaprogramming power without all the parentheses. Joy[3] was the first language to be described as “concatenative”, invented by the late Manfred von Thun; its operation is defined as a term rewriting system, but it can be implemented using a stack. If you want some theoretical background, Brent Kirby’s Theory of Concatenative Combinators[4] may be enlightening. Cat[5] was the first statically typed concatenative language, and Kitten is my s

Yeah, everyone’s got their eye on Rust as far as low-level expressive programming goes. Nimrod[1] also looks quite good: > Nimrod is a statically typed, imperative programming language that tries to give the programmer ultimate power without compromises on runtime efficiency. In my spare time, I’m working on a statically typed concatenative language called Kitten[2] with similar goals. [1]: http://nimrod-code.org/ [2]: http://github.com/evincarofautumn/kitten

Kitten, a statically typed, globally type-inferred, GC-less functional stack language, with opt-in layout-based syntax and an effect system to separate pure and impure operations. Disclaimer: I wrote this; it’s nowhere near complete, but not bad to play around with. We’re working toward a release in a few weeks, to include some missing language features and a new x86_64 runtime. https://github.com/evincarofautumn/kitten http://kittenlang.org/

For a modern relative, check out Factor (which is mature) or Kitten (which is not). [1]: http://factorcode.org/ [2]: http://github.com/evincarofautumn/kitten

Forth is basically at the level of an assembly language, but somehow it feels much more high-level and flexible. Having written a bunch of x86 and some Forth, I would say Forth is more pleasant to use once you’ve gotten over the small initial hump of stack-based programming. And anyway, if you write your functions correctly, the stack becomes an implementation detail. It definitely affects your thinking in higher-level languages, though—naming bits of state ends up seeming way less necessary than naming and composing behaviours. I’m writing a statically typed functional stack-based language called Kitten, in which the type system and local variables help you work compositionally and avoid managing the stack. It’s not yet ready for prime time, but you might be interested in following its development. Check it out! [1]: http://github.com/ev