Six programming languages I’d like to see

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Our great sponsors
  • SurveyJS - Open-Source JSON Form Builder to Create Dynamic Forms Right in Your App
  • WorkOS - The modern identity platform for B2B SaaS
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • DataLang

    Specification and refernce implementation of DataLang

    If you mean with a Graph language, a complex data structure language, you might have a look at https://github.com/FransFaase/DataLang which gives some ideas about modelling complex data structures and where I talk about the different kind of reference that you might want in such a language.

  • dafny

    Dafny is a verification-aware programming language

    Ada is already mentioned here.

    You also want to look at Dafny for a contract-based language: https://github.com/dafny-lang/dafny

    Since it has verification support it also covers the second point about semantic relations.

  • SurveyJS

    Open-Source JSON Form Builder to Create Dynamic Forms Right in Your App. With SurveyJS form UI libraries, you can build and style forms in a fully-integrated drag & drop form builder, render them in your JS app, and store form submission data in any backend, inc. PHP, ASP.NET Core, and Node.js.

  • Pluto.jl

    🎈 Simple reactive notebooks for Julia

    Pluto.jl[1] works like this. It’s a reactive notebook. It’s a really neat project.

    [1]https://github.com/fonsp/Pluto.jl

  • sdk

    The Dart SDK, including the VM, dart2js, core libraries, and more.

  • plasmic

    Visual builder for React. Build apps, websites, and content. Integrate with your codebase.

    I think Plasmic is doing that for React.

    https://www.plasmic.app/

  • cells

    A Common Lisp implementation of the dataflow programming paradigm (by kennytilton)

    The reactive programming idea reminded me of Ken Tilton and "Cells", which exploits the flexibility of CLOS (the Common Lisp Object System) to create a reactive programming language on top of Common Lisp.

    https://github.com/kennytilton/cells

    and he has slides from a talk

    https://github.com/kennytilton/cells/blob/main/Lisp-NYC-2018...

    to give context.

  • power-fx-host-samples

    Samples for hosting Power Fx engine.

  • WorkOS

    The modern identity platform for B2B SaaS. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.

  • scenebuilder

    Scene Builder is a visual, drag 'n' drop, layout tool for designing JavaFX application user interfaces.

    Yes it does[1] and it works on Desktop, mobile and web.

    JavaFX has SceneBuilder[2] which also fit the description but for some reason, it never caught on. Gluon seems to have that work not only on desktop, but also on mobile.

    [1] https://docs.flutter.dev/development/tools/devtools/overview

    [2] https://gluonhq.com/products/scene-builder/

  • magrittr

    Improve the readability of R code with the pipe

    R (yes, the statistics language) has exactly this.

    You can literally extract the body of a function as a list of "call" objects (which are themselves just dressed-up lists of symbols), inject/delete/modify individual statements, and then re-cast your new list to a new function object.

    I don't know why the original devs thought this was necessary or even desirable in a statistics package, but it turns out to be a lot of fun to program with. It has also made possible a wide variety of clever and elegant custom syntaxes, such as a pipe infix operator implemented as a 3rd-party library without any custom language extensions [0]. The pipe infix operator got so popular that it was eventually made part of the language core syntax in version 4.1 [1].

    [0]: https://magrittr.tidyverse.org/

    [1]: https://www.r-bloggers.com/2021/05/the-new-r-pipe/

  • docs

    Red-related user documentation repository (by red)

    The interesting semantic relationships are those that let the machine automatically deduce optimizations

    > I also like the idea of modifying function definitions at runtime. I have these visions/nightmares of programs that take other programs as input and then let me run experiments on how the program behaves under certain changes to the source code. I want to write metaprograms dammit

    Lotta metaprogramming in Joy. Many functions work by building new functions and running them, it's a natural idiom in Joy.

    - - - -

    > A language designed around having first-class GUI support

    Red? ( https://www.red-lang.org/ )

    > Visual Interface Dialect ... is a dialect of Red, providing the simplest possible way to specify graphic components with their properties, layouts and even event handlers. VID code is compiled at runtime to a tree of faces suitable for displaying.

    https://github.com/red/docs/blob/master/en/gui.adoc

    > You can’t work with strings, json, sets, or hash maps very well, date manipulation is terrible, you can barely do combinatorics problems, etc etc etc. I want a language that’s terse for everything.

    That also sounds like Red.

  • TOGVM-Spec

    Specification and test cases for TOGVM

    As far as graph-based languages and languages with arbitrary metadata and relationships between objects are concerned, I've been mulling over a language where expressions are represented as RDF graphs and that has built-in support for manipulating RDF graphs. I've use the concepts as an intermediate representation for functional expressions in a few different systems (including Factorio's map generator), but haven't yet had the motivation to really flesh it out into a full-blown language. https://github.com/TOGoS/TOGVM-Spec

  • imba

    🐤 The friendly full-stack language

    Imba is a compile-to-javascript language that makes HTML and CSS first-class parts of the language as well as react-like custom components. Its the fastest way to create UI that I've found.

    https://imba.io

  • inform

    The core software distribution for the Inform 7 programming language.

    Did you know Inform is now (finally) open source?! https://github.com/ganelson/inform

  • letlang

    Functional language with a powerful type system.

    For a contract based language and a "really dynamically typed language", I'm working on https://letlang.dev

    And it's because I haven't thought yet about how to do static type checking with such a feature.

    I haven't got any time to work on it in the past few weeks, and I'm the only dev (would really love some help). So, it will be ready when it will be ready :P

  • roast

    🦋 Raku test suite

  • prusti-dev

    A static verifier for Rust, based on the Viper verification infrastructure.

    For contract-based programming, I'm personally planning on experimenting with https://github.com/viperproject/prusti-dev

    The withdraw example would look something like

        impl Account {

  • Svelte

    Cybernetically enhanced web apps

  • LPeg-Parsers

    Parsing common data formats via LPeg

    When I need to parse text with Lua, the first thing I reach for is LPeg. It's great when you can create a standalone expression to parse, say, an IPv4 address, then reuse that in a larger expression. And the data can be transformed as it's being parsed (say, converting a string of digits into an actual integer value).

    I have a bunch of Lua modules based around LPeg: https://github.com/spc476/LPeg-Parsers

  • clog

    CLOG - The Common Lisp Omnificent GUI

    Have you tried CLOG?! It apparently matches the exact use case you described above. It’s a GUI first approach but its aimed is to be highly extensible. I only ask that you be gentle. It’s being built by a passionate developer in his spare time, but he’s making great progress.

    https://github.com/rabbibotton/clog

  • ODS_OpenExposureData

    Open data standards curated by Oasis.

    RMS never played nice on interoperability. I wouldn’t bet on the CDL to become a useful standard, because it is under-powered, under-specified and stagnant.

    The “open” alternative is OASIS. Their Open Exposure Data standard [1] is complete and supported by many industry participants. Unfortunately it’s a database based format, rather than a text based DSL, but still betterthan the alternatives.

    [1] https://github.com/OasisLMF/OpenDataStandards/tree/master/Op...

  • Glimmer

    DSL Framework consisting of a DSL Engine and a Data-Binding Library used in Glimmer DSL for SWT (JRuby Desktop Development GUI Framework), Glimmer DSL for Opal (Pure Ruby Web GUI), Glimmer DSL for LibUI (Prerequisite-Free Ruby Desktop Development GUI Library), Glimmer DSL for Tk (Ruby Tk Desktop Development GUI Library), Glimmer DSL for GTK (Ruby-GNOME Desktop Development GUI Library), Glimmer DSL for XML (& HTML), and Glimmer DSL for CSS

    In the ruby realm, this seem like what you are looking for...

    https://github.com/AndyObtiva/glimmer

  • rdl

    Types, type checking, and contracts for Ruby

    Similarly, Ruby had RDL - which implemented pre/post contracts and type checking prior to Sorbet. It was actually pretty nice, if slow.

    https://github.com/tupl-tufts/rdl

  • fuzion

    The Fuzion Language Implementation (by tokiwa-software)

  • impulse

    Impossible Dev Tools for React and Tailwind

  • Lazy

    Lazily evaluated (late-binding) definition for Dyalog APL (by abrudz)

  • jq

    Discontinued Command-line JSON processor [Moved to: https://github.com/jqlang/jq] (by stedolan)

    Most APLs work just fine with n-dimensional arrays, even though the language only lets you write 1-dimensional array literals. So in practice, we write 1-dimensional arrays and reshape them as needed.

    My point is just because you use a sequence-based input method (a programming language) doesn't mean you can't express structured data.

    For example jq[1] does a decent job of expressing queries and transformations on JSON (JSON data are trees rather than arbitrary graphs). But trees are a very important type of graph, and I think a language with first-class support for trees would be in a better position to handle arbitrary graphs than a typical programming language.

    [1]: https://stedolan.github.io/jq/

  • halo

    An experimental graph-based meta programming language (by vinodkd)

    I'm a little late to the party, but humbly submit my thoughts/design from a while back for your review/feedback: https://github.com/vinodkd/halo/blob/master/doc/UserGuide.md...

  • NimContracts

    Nim Language design by contract (DbC) library.

    A more practical one might be this contracts library https://github.com/Udiknedormin/NimContracts

  • InfluxDB

    Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts