Six programming languages I’d like to see

>> A serious take on a contract-based language

Ada has design-by-contract as part of the language:

https://learn.adacore.com/courses/intro-to-ada/chapters/cont...

Since Ada is used for safety-critical systems programming you could argue that it is very serious about it.

>> And tool integration! One of the coolest things Eiffel sorta did was use contracts to infer tests. If you have contracts, you can use a fuzzer to get integration tests for free.

How about tools that extend design-by-contract to formal verification?

https://learn.adacore.com/courses/intro-to-spark/chapters/01...

SPARK is limited to a subset of Ada, so it is not without limitations, but it can be very useful depending on what you are trying to do.

I'm a little surprised that nobody has pulled off the "VB6 of javascript". I don't mean one of the purely no-code products, but like a literal "create a new page, drag a button, then double click it to hop into the code for a new route and a new component and go straight into the onclick handler".

Maybe that's harder than I can imagine, or it exists and just isn't a very good idea in practice (how would you even do responsive?) so it's not that popular.

VB was a garbage language by modern standards but I always liked that they gave you a visual builder, but didn't try to hide the coding from you too much.

Depending on if you count it as a serious programming language, Racket has pretty much all the contract stuff. It has dedicated syntax for contracts, tight integration with the module system, and contract-random-generate attempts to generate a value satisfying a contract so writing an auto fuzzer wouldn't be too hard. In fact, I think Racket's system predates Clojure since there was the 2002 paper "Contracts for Higher-Order Functions" discussing it and Clojure first appeared in 2007.

The only reason I would ever use Clojure instead of Racket would be if I needed to work with the JVM ecosystem or the browser via Clojurescript (which are compelling reasons).

Totally agree about a good calculator language.

As more of a Sys Admin / scripting type, I felt happy and sad at the same time at the actual mention of Visual Basic.

VB is often scoffed at, and probably to an extend rightfully so.

But those (i.e. VB1 through to VB6) were the ONLY languages that I ever managed to create useful, finished tools and programs in. Maybe it's part psychological, but I needed the approach where I created a neat UI first, got my methods pre-populated for me, and had something tangible to look at early in the process. Then went on to fill it with all with custom code. Yes, it's BASIC, but it was extensible. People I knew wrote OCX and such control elements, and code routines in DLLs in C/C++ and integrated that into VB projects, so the sky was still the limit.

Staring at an empty text document with possibly some header file statements never evoked the same creativity with me that VB did.

p.s. my proudest creation was a Windows 3.1 UI around the MS-DOS packing program "arj", for those who remember. Had I been a better businessman, that might have predated WinZip :)

> A language designed around having first-class GUI support

Delphi and friends[1] is still out there. There's also Lazarus[2] if you don't want to fork off a few grands.

[1] https://www.embarcadero.com/products [2] https://www.lazarus-ide.org/

The reactive programming language one is really interesting. A compiler ought to be able to compile "normal" straight-line code into conventional efficient code. It's hard to know how that sort of thing would "pollute" the rest of the code, though, like, will every program turn into a rat's nest of dependencies such that it's just impossible to manage or what? Hard to tell without trying, especially since developing such a language would also require significant effort into developing a standard library and best practices to go with it even if the language was in hand today. And one hell of a debugger. Circular dependencies are a problem, too; I'm inclined to ban them but that's probably beyond what a type system can help you with, or at least, any type system I currently know, so it's going to be an adventure.

Still, there's a lot of things that would be more useful with such a language. In-memory highly-correct cache invalidation would become trivial code to write. In fact I think the cache would actually update itself live. Out-of-memory cache invalidation might be pretty easy. Certain auditing things would be easy. UIs would probably take some work to get right but would be interesting, at the very least. Game programming would also be interesting; a lot of game patterns would be incorporated into the language at that point.

Probably need to be lazy; I suspect proactively recalculating everything all the time would be a bad idea. Haskell has pushed lazy programming a long way, but "re-thunkifying" a previously calculated cell would be a new frontier.

Come to think of it, while I think the performance could be improved and you'd want to lift up to a full language eventually, I think a good Haskell programmer could bash together a prototype of this in a few days and start playing with it. It's going to need a lot of playing with before someone casts it into concrete as a language specification and corresponding compiler and runtime.

Mathematica is a decent general-purpose language (though closed-source) and its "map the factorial function over the list" is exactly the same length as the quoted J code:

    #!&/@l

It has the same "everything is a list" problem - it's really verbose at handling strings, for example, and last I checked its date-time handling was not only verbose but also [flat-out wrong](https://mathematica.stackexchange.com/q/239480/30771). But it does support the dynamism mentioned immediately below, if you use `SetDelayed` (`:=`) rather than `Set` (`=`).

None of these are top of my list. Mine is a better PHP.

To be clear, I like PHP. It actually has many attributes that make it almost ideal as a Web development language, most notably:

1. Pretty much everything is request-scoped. This makes it a lot harder to leak resources when everything is torn down;

2. A stateless functional core. This avoids a lot of class loading that has dogged Java (as one example);

3. No ability to start threads. This is actually a positive. Most application code should avoid creating threads like the plague.

But PHP comes with a lot historical cruft. It's type system is also primitive (Hack is a better example of this).

Where I think this could really shine is in data analysis (ie the numpy/scipy realm).

Inform 7 is the closest thing I can think of to "everything is a graph". Basically, objects in the world are vertices and relations are edges. When you first encounter relations they don't necessarily seem that exciting, but it turns out that having relationships between objects be a first-class concept really changes the way you think about and design systems.

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.

Nice article! I'm building a language (https://flame.run/) in Rust that aims to have WebGPU+GUI support built-in. I'm playing with refinement types, which you effectively described in the second-to-last section. I'm not familiar with contract-based languages (other than Solidity), but I think refinement types would allow specifying function parameter requirements in a similar fashion to what you described in your contract-based language section.

> A serious take on a contract-based language

In Shen, the contract rules applied on each function are themselves a Turing complete language::

https://thestrangeloop.com/2014/shen-a-sufficiently-advanced...

https://shenlanguage.org

"static type checking based on sequent calculus"

"one of the most powerful systems for typing in functional programming"

Joy (implemented in Prolog) could tick some of these boxes.

> window2 is an optimized version of window1 and should have the same outputs for every input. I should be able to encode that in the language, and have the tooling generate checks showing the two are the same, and also run benchmarks testing if the optimized version actually is faster.

That should be possible with Joy, it's certainly something I want to explore. 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.

Imagine if the computing world would have standardized on Lisp and Smalltalk 40 years ago.

If Alan Kay had got microprocessor companies to steal the Xerox microcode design like they got Apple to steal the GUI design, then the genius compiler engineers optimized the the heck out of it all.

I can only shudder at what the supercomputer in my pocket would be capable of.

I'd like to see a language that can clearly model concurrency using a Petri Net-like structure, ie a data flow language with flexible state/transition handling.

Technically, the runtime is the easy part (relatively speaking). Modelling an array of swimlanes on a plain-text 2D page is the real challenge here IMO.

>A really dynamically-typed language

Raku, previously known as Perl6, has this[1].

sub MAIN(Int $a, Int $b where 10 < $a < $b > 20) { say "OK: $a $b"; }

You can also pull out the "Where" clause to ouside the function and make it define a new type.

Raku is a very awesome language in general, for more reasons than one.

[1] https://andrewshitov.com/2020/08/14/the-pearls-of-raku-issue...

About "Everything is a Graph", I tried to design programming languages for graph processing a few year back. The problem here is the "language" part as language always implies sequence (because that is what text is). Sequences of statements just don't cut it. In order to efficiently work with graphs, you need to work in graphs. Thus, it becomes a program graph rather than a programming language. And at that point you run into issues of general tooling. Every single tool ever invented around programming is used in combination with text and sequences.

In retrospective it is funny how everybody implicitly assumes that the next big thing will be yet another programming language. And I am not talking about no-code or AI code synthesis.

> A better calculator language

Especially with reactive programming as an ask there, I would recommend Julia with Pluto.jl (Pluto is a reactive notebook).

> A really dynamically-typed language

Julia ;) It is really dynamic, has meta-programming (macros + staged functions), solid semantics around eval/invokelatest that still allow for optimizations and you can add types at runtime (not modify them though).

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.

I'd like to see more languages with built-in, language level support for unit tests. Pyret (https://www.pyret.org/) does this but is considered a "learning language". I'm aware that to many people co-locating units tests with the functions they're testing is "bad" but I find it to be quite the opposite. The two are so tightly coupled that having the unit tests in a separate file, sometimes in a separate source tree, is counterintuitive to me.

I'd love to see a language with first class relational data types. This would basically be Turing-complete SQL with better syntax and obviously with a very modern language outside the relational stuff. Bonus points for providing hooks to allow transparent persistence of data, making the program and its database potentially the same thing and allowing easy persistent state programs with complex data.

This could theoretically be added to other languages with libraries (with varying elegance depending on the language), but a real first class language would be carefully designed so that everything is serializable and deserializable with excellent performance. Things that fundamentally are state like network connections would also have to be carefully handled in some way where their essence was persisted such that the program could restore them and rebuild their state.

This would pretty much give you an ORM without the impedance mismatch and would eliminate a TON of "CRUD" code and boilerplate.

The "reactive calculator" language the author wants is just Julia running in a Pluto notebook: https://github.com/fonsp/Pluto.jl

> When I’m trying out lots of different equations, keystokes matter a lot.

That's a pretty weird way to do math, honestly. Shouldn't you figure out what equation you need and then just type it? If you're off by one or whatever, adjust it then, you're still only typing it twice.

Elixir function marching feels kind of like contracts. You specify different variants of the same function for different contracts of what the inputs thrown at it are.

I found that for much of my code it really separated the “where to next” from the “what to do”. And I became acutely aware of how many of the statements in other languages are more about “where does the code go next” and less about getting stuff down.

> and basically no languages have an implication operator

Prolog does, but more intriguingly, so does Nix!

His python code can be shorten to

  from math import *
  prod(map(factorial, l))

which isn't much longer than his J code especially if you count the number of tokens rather than the number of characters as the J code uses ridiculously terse names.

I'll keep my moaning about VB6 and JavaFX to myself. These days I think HTML5 and a decent theme is probably enough for everything. Yes it can sometimes suck, but there doesn't seem to be much love for heavy app development anymore.

> 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

I've been working on an extremely dynamic programming language for a while. Ricing away on the syntax to make it as flexible as possible, whilst maintaining readability.

One of the things that already works is some insane metaprogramming. It doesn't really have functions. It has callable lists of things. Which means you can modify them at runtime (still working on the names for the functions for doing that).

It is stack-based, so it's a little quirky, but as a taste of some very simple meta-programming:

    block
        varname:
        add! 1 $ $varname
        : $varname
    end
    inc-env:

    a: 1
    inc-env! a

Bare-words are a symbol-type. So they only resolve from the environment when you ask for it with the $ instruction, which is how the above works. A little tedious, but does enable all kinds of dynamism.

Yes please to contracts.

Dependent types and things like that are probably great. Being able to prove correctness is great. But I would settle for a way to declaratively express invariants and then let the language for the most part take care of inserting checks (in debug or using a special mode perhaps, or all the time) and generating tests/property tests. Why isn’t this more of a thing?

It’s not exactly a language but the Emacs calculator (aka GNU Calc) can do a lot of the things J does for the author. Product of factorials would be:

  v M ! v R *

Where the v may be capitalised if you like and the spaces are the way the commands are written but aren’t typed. That decomposes into some easy mnemonics: Vector Map factorial, Vector Reduce multiplication.

It has a bunch of mathematical features, a quick interface for plotting simple graphs (with gnuplot), some symbolic algebra, and it sort-of has the reactive feature too. (I think there’s also a mode for using it in files).

Date handling is ok but simple (a date/time is internally represented as a Julian day so if you add 1 to a date/time you get the next day; times go into the fractional part. Leap seconds / time zones aren’t handled. There is an option to configure when your calendar switched from Julian to Gregorian.

It’s usually fast enough for what I use it for but it can be limited by performance.

The items "A serious take on a contract-based language" & "A language with semantic relations" are covered pretty nicely by Ada's SPARK subset/tools... and the really great thing is that the "aspects" are part of the code and don't "go stale" like annotated comments do.

Interesting to see the complaints on J. I've been playing with the Q language (basically K with some sugar) that is part of KDB+ and I think it solves all your problems in that it is a lot cleaner/simpler, very fast, support for dictionaries, strings, JSON, datetimes (it is a database too), very terse file IO...etc. The only drawback is it's a commercial product. Who knows though. Maybe they would give you a pretty cheap license if you agree to use it mostly like a calculator (not for large-scale financial analysis). The whole install was basically a single executable and a license file. Very elegant. The doc is finally pretty good too.

Edit: I tried using J and the install was pretty large iirc and the whole language is just too big and complicated. I know you can do cool stuff with it, but it just seemed to me that the cost was too high relative to benefit. Your mileage may vary.

  input = 1

  out1: input + 1
  #out1 is now 2

  input = 4
  #out1 is now 5

  out2: out1.replace(+, -)
  #out2 is now 3

  # let's pull an APL
  input = 4 2
  #out1 is 5 3
  #out2 is 3 1

The reactive programming idea a la Excel but text-based looks really neat. I'd love to play around with that kind of thing.

Pyret has interesting contract functionality.

Lua is based around tables, which, aren’t quite graphs but seem relatively close enough. What is a graph if not a collection of points associated with their edges?

As far as semantic function relations, I could swear Ada has something like this, but it’s been more than a decade since I’ve touched any.

“A serious take on a contract-based language“

Not ambitious enough. We already have dependent type systems and what I will call “property based types” since I forget the proper name e.g. https://ucsd-progsys.github.io/liquidhaskell-blog/.

The compiler can check anything from silly out of bounds conditions to more complex assertions.

Even without that, a good type system will allow you to alias types but have a constructor do a check. Once you use the Percentage0_100 type you know that it must be in that range, and the method doesn’t need to check it again.

In think Haskell is “too much” for a lot of teams, but sprinkling in some compile time assertions and making that ergonomic with linting and so on would be a boon on par with async/await.

“Unit test?” no need, I have a proof!

All six features listed are very redundant or useless, in my opinion.

Contracts? how they're different or less verbose than plain asserts? what they do better?

"reactive programming"? if remove that strange code editing "replace", just a chain of definitions instead of variables in, say, ruby, gives you basically the same effect.

etc.

What I'd love to see is a language with a first class grammars to replace many uses of regexes or badly written DSL's, like what Perl6 tried to do.

and, somewhat related (both are using backtracking), adoption of some of the ideas of https://en.wikipedia.org/wiki/Icon_(programming_language), not on a whole language level, but in some scoped generator context would be nice for some tasks I had to do.

  input = 1
  
  out1: input + 1
  #out1 is now 2
  
  input = 4
  #out1 is now 5
  
  out2: out1.replace(+, -)
  #out2 is now 3
  
  # let's pull an APL
  input = 4 2
  #out1 is 5 3
  #out2 is 3 1

Not quite as sleek syntax, but in APL with my Lazy library[1]

        input ← 1
  
        ]lazy out1 ← input + 1
        out1
  2
        input ← 4
        out1
  5
        ⎕FX'out1' '\+'⎕R'out2' '-'⎕NR'out1'
        out2
  3
        input ← 4 2
        out1
  5 3
        out2
  3 1

[1] https://github.com/abrudz/Lazy

I want a language for safe collaboration. Suppose I create a GPL-licensed library for decoding mpeg4 that I publish somewhere. Someone should be able to fix a bug in that library and publish a new with minimal involvement from my side and minimal overhead work. I shouldn't have to review pull requests or anything. It should all be automatic and the language should protect against malicious users inserting flawed code.

Copyright would be handled using a block chain so every commit's author would be publicly visible to users of the library.

The "source code" would be stored as a call-flow graph and perhaps nodes would have different permissions to sandbox the effect of untrusted contributors changes.

I'm curious what the author means by "everything is a graph". Are graphs the primitives of the language? How are graphs defined or specified by the programmer, without using an even lower level primitive?

The author says:

> Give me a language where key-value maps are emulated with directed bipartite graphs

So this means you can't define graphs using key-value dictionaries (like Smalltalk or Javascript with their objects primitives). So how exactly are these graphs defined? RDF format?

Something I've found while trying to design languages is that the hardest part is running into contradictions and circular logic. And I feel this "everything is a graph" idea will very quickly run into this issue.

>> Everything is a Graph >> Lisp: everything’s a list

Actually, the universal 'cons' cell data type of LISP (which is used to build lists) allows to represent graphs. Take, for example, Common Lisp. There are read-macros which make this possible: The expression #1=(hello . #1#) builds a circular list that only contains the symbol "hello" [1]. This example can be extended to build graphs.

[1]: https://letoverlambda.com/index.cl/guest/chap3.html#sec_5

> The standard bearer for contracts used to be Eiffel, which people stopped caring about in the mid-90’s. Nowadays the only mainstream language to get serious about contracts is Clojure. Most languages have a contracts library, which mean the language doesn’t have affordances to use contracts well. Take the predicate is_sorted(l)

Some languages though have contracts as a library, but that library uses tools of the language, to actually change the language. Languages with capable macro systems! Just because something is a library, that does not mean, that it will not integrate into the language, even beyond a library function level. In language with a capable macro system, one can create new keywords and forms, which are just as much part of the language, as predefined things. It allows to create ones "affordances". With all the interest in language features, I am surprised, that this was overlooked.

The post inspired me to try myself at creating a macro in Scheme / GNU Guile, which implements the "requires" and "ensures" idea, although evaluating at runtime: https://notabug.org/ZelphirKaltstahl/guile-examples/src/d749...

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

The withdraw example would look something like

    impl Account {
        #[requires(amount <= self.balance)]
        #[ensures(self.balance >= 0)]
        pub fn withdraw(&mut self, amount: uint) { ... }
    }

and Prusti has a good story for going from this to larger proofs.

I would love to see a programming language with some sort of bitemporal data store built in. Let me define dataflow graphs, including highly stateful logic over streams of data, but let me go back and change data, or fix bugs and replay from the beginning of time and view the state of the system (in a nice REPL) at any point in time. Gimme a fast, distributed runtime that can scale to any level of complexity or data size.

I can imagine it being Materialize who build this first but in my heart of hearts I’d love it not to be SQL.

I want an IaC and nixos level language with prolog inspiration. Let me express how to go from fact to goals with constraints.

It would probably make more sense than HCL or Pulumi.

Agents based language are close in theory but they are really targeted at specific simulation and not at explaining what went wrong.

It would also make it easier to do partial application and resumption of it. And probably make constraints for security easier.

Probably make composition of infra level work easier too.

The dynamic typing example doesn't have anything to do with dynamic typing and is in fact already a feature of some statically-typed programming languages.

As TFA mentions, Smalltalk probably does it as well, but Common Lisp has all of the features for "A really dynamically typed language"

well since all graphs can be represented as binary graphs and bgs can be conmfortably represented in lists, Lisp is de facto the friendliest graph language. But I agree with the sentiment, specially in regards the syntax... something new has to be imagined in order to representa language oriented toward graph traverse and manipulation.

Give me a language like Rust that allows me to define an efficient concurrent garbage collector as a library.

Re the "everything is a graph" idea, Mathematica has been building primitives for some time toward this idea where literally everything is a graph: https://www.wolframphysics.org/

We use an internal language at work thats a graph based language with first party GUI support. Some interesting info about it:

* There is just a few primitive node types (Class, Method, Attribute, Relationship, GUI Bucket) with the rest of the system being derived off of that.

* Underneath is a replaceable layer of java (+js/html for UI).

* Still not sure if it's quite front or back end code, as it contains business logic, GUI info, and largely runs on the server.

* Back end improvements happen automatically and system wide. The limiting nature of the graph ensures minimal regressions.

* Most of the SKU product code is contained within this graph, making for definable relationships between any part of the code.

* Internal languages mean lots of internal tools that enable better management of the graph.

I would like to see a proper language with built in support for Unix Shell commands. Similar to bash or perl with a use Shell import, but without the limitations of bash or the craziness of perl.

I really like the idea of zx, but still doesn't look clean enough to me.

This list of wanted language features is quite interesting.

> A serious take on a contract-based language

As the article itself notes Clojure does support contracts in the language and with libraries. But there has been a ton of research about that, e.g. JML [1].

> A language with semantic relations

They can be expressed in contracts (e.g. Clojure) or with property-based test frameworks (e.g. Haskell, Clojure, and many others nowayday).

> Everything is a Graph

See graph rewriting, e.g. [2]. That was just my first google hit with the proper search term.

> A better calculator language

That idea looks to me like automatic transformation from offline to online algorithms [3]. I am not aware of any compilers being able to do that. But dataflow graphs can be used to design such systems. A list of such languages or libraries (e.g. for Clojure) can be found in this Stackoverflow article [4]

> A really dynamically-typed language

As some other answers here already mentioned modern static type systems are able to express, new types at runtime, e.g. with Scala's path dependent types. Again Clojure has an interesting entry here: clojure.spec [5], a runtime represented specification language, which can be used together with contracts or to formulate proeprty-based tests, or anything else you would like to do with it.

Btw, I've only toyed with Clojure so far and I used to be an avid proponent of Haskell/ML-style static type systems.

[1]: https://www.cs.ucf.edu/~leavens/JML/index.shtml

[2]: https://link.springer.com/chapter/10.1007/978-3-642-32211-2_...

[3]: https://en.wikipedia.org/wiki/Online_algorithm

[4]: https://stackoverflow.com/questions/461796/dataflow-programm...

[5]: https://clojure.org/guides/spec

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 [mostly numeric] 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

For calculator languages, I think there are several choices. Depends a bit on what you know, and what you need...

Frink (https://frinklang.org/) has been around for ages, and is rooted in physical unit conversions

Calca (http://calca.io/) has come up a handful of times. It looks pretty reasonable

R, if that's your flavor

Anything with a REPL. Though the OP suggests these are cumbersome, I'd counter argue that anything you know well is usually more efficient than learning something new.

A very long list of commercial tools: Matlab, Mathematica, WolframAlpha, STS, SAS, etc

This is very nonambitious, but I’d love to see a Clojure with less LISP. That is - something like JS syntax but with immutable by default types and const only bindings. Macros would be great too, even if they require a different compilation mode. Top it off with great standard library that has _all_ the collection operations you’ll ever need (e.g. partition-all and dedupe in Clojure). nREPL support or the like is a hard requirement.

Spending the last 6 years writing Clojure has been great. That said, the parens don’t add positively to the experience. They feel like semicolons in C - “the compiler is too dumb to understand this so I have to help it.”

What I really miss is a lang that can be used to write code efficiently on smartphones.

> A language with semantic relations

This is a cool idea especially around a formal structure to express relationships between parts of your code. As to the example in the article on this, it seems property based testing is a decent way to achieve something like this with existing languages.

A simple example of a property based test for a `const add = (a, b) => a + b` function would be that the result of the invocation is always larger than the arguments IE

  expect(add(a, b)).toBeGreaterThan(a);
  expect(add(a, b)).toBeGreaterThan(b);

And then you can randomly generate or fuzz the values for a and b but the test should always pass

> I miss VB6.

Me too. But there is something nice on Linux called GAMBAS: http://gambas.sourceforge.net/en/main.html

A guy I know actually did make a graph programming language, implemented on top of neo4j. It was very slow, but he did use it successfully for analyzing SQL stored procedures and finding fraudulent transactions.

What I would like to see is a language that as easy to learn & use as python/ruby/etc, but based on rust and rust-like, using rust libraries if at all possible, with garbage collection, so one can have an easy entrypoint for anyone who wants that, and if ever needing the full performance etc of Rust, change a compiler switch (or something) and the full Rust kicks in.

In other words, a step-by-step developer growth process from simple to hard, maybe 2-4 levels, and you never have to throw away what you already learned and start over, when going to the next step.

A language designed around having first-class GUI support: Tk dialect of Tcl

Dart is a language optimized for use in the Flutter GUI framework. Well done.

> A language designed around having first-class GUI support That's Imba https://imba.io

And it's fast, enjoyable and productive

D has contracts built in.

https://dlang.org/spec/function#contracts

For the really-dynamically typed language, that for sure is covered in Smalltalk.

And for the first-class GUI support, in its own way too, but also Swift in XCode is very very good.

The language I want is a specification language (a bit like Pluscal or P) which allows me to specify distributed system behavior, then ask both correctness (liveness/safety) questions and quantitative behavior questions. I wrote a bit about it here: https://brooker.co.za/blog/2022/06/02/formal.html

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

For reactive programming, verilog does that as its primary function. You can write imperative code as well. But it is a very primitive language that doesn't even support structures and loads of historical cruft. Systemverilog improves on it greatly. VHDL is contemporaneous with verilog and is much more principled because it was modeled on ADA. I have never heard of anyone using verilog for anything other than modeling logic.

The reactive programming idea is implemented by the Kotlin Compose project as a compiler plugin so it behaves as a language feature. Compose is confusingly named in that there is a more popular Android UI toolkit with the same name built on top of the reactive feature. But Compose the compiler plugin is available by itself without the UI thing.

I've been playing around with it and find it can really simplify a lot of code.

Some versions of K have reactive programming -- they call them views.

normal assignment:

var : expression

view:

var :: expression

https://code.kx.com/q/learn/views/

https://code.kx.com/q4m3/9_Queries_q-sql/#911-views

+1 for "I miss VB6"

Using a dynamic web tooling product at the moment, and at first I was enthusiastic, but it's crippled compared to VB6

I'd like to see a language with baked in support for dependency injections, so that my functions can take two types of parameters: its "real" parameters, which it needs to perform its function, and "dependencies", that are passed implicitly by the runtime.

Basically, a formalization of Dagger/Guice into a language.

Is there a relationship between contracts and proof languages like Idris, or are these completely different approaches?

I thought Pascal's ability to specify the bounds of an array were cool:

    vector = array [1..25] of real;

> A better calculator language

See Calca: http://calca.io

I miss VB too. It's amazing how simple and intuitive it was comparing to how we create UIs nowadays.

Is there a good programming language and environment for kids? I started learning coding in my own around 10 yrs old with qbasic. Scratch is super aawesome, but what is the next level up from that that is actually typing the code out instead of moving puzzle pieces?

Recently I have been shopping for a configuration language that has static types and is easy-to-use and exports to common formats. Dhall came close but I was surprised to find that it does not support recursive types in a simple way. Maybe I should just use Haskell.

Is there a language where everything is observable? Like RxJS all the way down. Can that exist?

The one I want to see is an analytics PL where dataframes are 1st class citizen. The only ones that do that right now are SQL. But really pandas shouldn't be a library in python, it should be in python itself with a specific syntax

With respect to the everything is a graph language, I think SetL [1] is pretty close.

[1] https://en.wikipedia.org/wiki/SETL

I'm sorry but these all seem superficial to me.

E.g. contracts language could mean better understanding of substructural stuff so we can handle "real resources". But coming up with some syntax for this is the last step.

> A language designed around having first-class GUI support

Definitely qt, right? https://www.qt.io/

And HTML/CSS :downtrodden-developer-with-woozy-face:

> A better calculator language

Well there are many of them like MATLAB, IDL, scilab, R and others. Python is verbose because it's not a calculator language but a general purpose language. I find J unreadable.

> A better calculator language

https://calca.io/

> You know how annoying linked lists are? Graphs are 1000x worse.

I thought linked lists were one of the easier data structures to implement? Is he saying they're annoying to use or implement here?

There are plenty of really dynamically-typed languages. io is probably the most so of them, but I'd argue Smalltalk and even Objective-C are pretty up there.

What’s the point of contracts? Can’t you use tests for that?

“Everything is a graph”

This is sort of an odd thing to want. You need a diversity of data structures. And BTW the acronym not withstanding, lisp represents graphs not lists.

> A serious take on a contract-based language

This already exists: programming languages that supports refinement types. Examples are Liquid Haskell and F* (F-star).

I want a programming language that takes dynamic scope seriously. Not because I think it would be good, but I think it would be interesting.

For the contract language, I’d recommend checking out Daml! It’s a Haskell-based smart contracts language with some pretty neat behaviors

> I want a language that’s terse for everything. Maybe you could namespace operators.

Haskell and lenses is pretty nice here.

Solidity (ethereum cryptocurrency language) is based on contracts.

Svelte (javascript framework) has reactivity build in.

The closest examples I can thing of to these, in sequence:

- Idris (dependent types rather than contracts, but squint and the UX is the same) - Python's decorators enable some of this, but Aspect oriented programming may also be what they are looking for. Boomerang is totally different but also an exploration in this space. - Io, or even JavaScript fit this description - there's a calculator like this I am forgetting the name of at the moment - this looks like Dependent typing to me, see Idris above

I feel VB6 appeals to sys admin types who don't get kept up at night by misaligned padding or a misplaced pixel. It's similar to the MS Access crowd that happily pump out functional abominations without a second thought. My first UIs were made using AutoHotkey in the early 2000s and while I felt empowered, I ditched it as fast as I could.

For a GUI-focused languages, we have C# and Java.

For a fully dynamic scripting language, look no further than Python.

Function inheritance? We have decorators in Python already, and most functional languages support seamless function composition. Take your pick between Haskell, Lisp, Scala and even Rust.

Designing a new languages needs to have a pragmatic purpose and sometimes, valid ideology.

> (Someone’s gonna tell me this is 100% smalltalk for sure)

IIRC Objective-C can bind new methods at runtime

I'd like to see one like rust, but with an AI-enabled compiler that can help you by suggesting implementations, and also estimating time/space complexity for you, detecting infinite loops, etc. So rust + copilot, but more, and designed into the language from the start, not cobbled together from public repos.

Graphs are really common data structures but there hasn’t yet been an “everything’s a graph” language

Nearly all common languages like Python, JS, Java, OCaml, etc. let you express graphs with records / objects. Everything is a graph!

If you want a homogeneous graph, you just declare a single node type, like

    class Node:
      edges: List[Node]  # or maybe Dict[str, Node] if you want them to be named
      payload: int

- Or you can have a heterogeneous graph with many different node types.

- If you want to label the edges, you can reify them as their own type

The whole heap is graph-shaped!

It's true that many programs in these languages are more tree-like than graph-like. And sometimes imperative code to manipulate graphs is hard to visualize.

But I think there doesn’t need to be a separate language of graphs for this reason.

---

If you want to see graphs done in plain C, look at this DFA code by Russ Cox:

https://swtch.com/~rsc/regexp/regexp1.html

e.g. Implementation: Compiling to NFA

(copy of lobste.rs comment)

I want to see an emulated hardware design lang to make desktop apps.

I’d like to see a modern BASIC-like language with line numbers :)

Aren't contracts just a worse form of dependent types?

Java ecosystem but C# language.

There needs to be a J# project lmao

> keystokes matter a lot

Meta

Regarding graphs, I also have wondered why thy are not part of the regular suite of collections / literal syntaxes in most languages. In fact, they are really rare to even see in day to day programming, despite that most of our problems could make use of them in some way. I think part of it must come down to that you can't come up with a satisfactory way to encode graphs of data in a text-based literal. You will have to have a lot of repeating of nodes depending on how you want to express it. Take this simple graph from Wikipedia for instance https://upload.wikimedia.org/wikipedia/commons/thumb/5/5b/6n...

We could express this as an adjacency list like

    Graph{  
    1 <-> 2  
    1 <-> 5  
    2 <-> 3  
    2 <-> 5  
    3 <-> 4  
    4 <-> 5  
    4 <-> 6  
    }

So there's already a lot of repetition of the node labels, but in real life applications you would probably have actual data associated with each node (like maybe a user_id, or a name, etc, whatever the "elements" of your graph are). Actually, you would in most cases have some key that identifies the node (like user_id), and some other data associated with the node (like date of birth, locale, etc). So the above notation would force some kind of notation like:

    ("user1", (1970, USA)) <-> ("user2", (1980, UK))  
    ("user1", (1970, USA)) <-> ("user5", (1990, RU))  
    ...

So now the notation would require not only repetition of the node name, but also the data itself. This would be even more of a problem if the data was not a literal but was computed, like: ("user2", (getDateOfBirth("user2"), getLocale("user2"))

So then the way around this would be to use the programming language's own variable/identifier system, like

    var user1 = ("user1", (1970, USA))  
    var user2 = ("user2", (1980, UK))  
    var user5 = ("user5", (1990, RU))
    
    Graph{  
      user1 <-> user2,  
      user1 <-> user5,  
      ...  
    }

or perhaps some other node registration system, and then just repeat the labels

    Graph{  
      Nodes {  
        ("user1", (1970, USA)),  
        ("user2", (1980, UK)),  
        ("user5", (1990, RU)),  
        ...  
      }  
      Edges {  
        "user1" <-> "user2",  
        "user1" <-> "user5",  
        ...  
      }  
    }

So now we've avoided repeating data, but we still have to repeat nodes. In some situations, a different way of expressing a graph would also be preferable to adjacency lists (you might want an adjacency table, but in sparse graphs the list is more efficient)

but by the way, for your graph system to be generally useful, you'll have to come up with a syntax and flexibility of design that ergonomically allows graphs that vary in:

directedness: support for undirected and directed edges edge wights and data: edges could be identical or they could have weights or even keys and other attributes associated with them

graph/multigraph: can there be multiple edges between the same 2 nodes?

in statically typed languages, the data type of the "key" of the nodes, the "value" of the nodes, the "key", "value" of the edges, all have to be represented to some degree in the language's type system, so at least 4 generic parameters in a graph

So, seems that there is just a huge design space and a variety of different usecases that makes coming up with a simple solution to the general problem very difficult.

Basically the man wants two opposite things.

He wants contracts which is basically dependent types. These rules live in types and already exists in agda, Idris and coq and has a range of tradeoffs.

Essentially these languages can enforce static checks and "contracts" so powerful you don't need unit tests. These "contracts" cover more ground and are safer then tests. The tradeoff is you need a big brain and lots of time to write these things.

Then he wants a language that is truly dynamic. Which is like the opposite.