Ask HN: What would be your “perfect” programming language?

Ruby + POSIX threads

Go without the garbage collector.

  import "C"
  import "Unsafe"

Python syntax and libraries with nim’s packaging and distribution

I've actually been having a lot of fun building stuff using OpenAI Codex. I suppose something where I could write the specs and the AI spits out something resembling HTML/JS/CSS so that I can verify that I communicated correctly.

  - create a dark mode palette for the page based on this image: {file path}

  - make a form with a single name (not first and last), email, country code, phone
  -- this form should allow a document upload when clicking
  -- allow drag and drap to upload documents
  -- add a tick box that says "I agree with terms and conditions"

  - this form should have input validation
  -- all fields should be secure from injection
  -- name can be anything except number
  -- file type is documents (not images but including PDF)
  -- absolutely ban exe files

  - upon valid input, send this form to {URL}
  - if the response from {URL} is valid, redirect to {success page}
  -- else show the error message if it's type 200

Rust with Lisp syntax so I could actually write unhygienic macros without learning a bunch of arcane stuff about compiler internals.

Ruby with python style type hints

A C++ dialect that dropped exceptions, headers and backwards compatibility (especially backwards compatibility with plain C). Everything that can be is statically linked, so no fussing about ABI. Explicitly no support for dynamically linking the std lib, or passing std lib objects across ABI barriers. One big build in a compiler that runs as a daemon, no messing about with recompiling the world in each translation unit. One implementation that works the same everywhere because it's the same code. No committee, no standard. The implementation is the standard and there can be only one.

Have thought about this a lot, I really want it. I even started messing around with implementing it, but it's just a toy (an abandoned toy, even) for now.

Very abstract question, but the code is compiling, I'll bite right in.

I think the 'ingredients' for my ideal language are more or less the following, in decreasing order of importance:

- Quality of the ecosystem. You can't buy or engineer this, it kind of has to happen naturally. Good FFI and trying not to be a "let's rewrite the world" language help immensely. It's controversial to put this as the most important bullet point, but the world we have to program in is much more complicated than it was even just 20 years ago. Programs live in an environment and have to interact with databases, networks, etc. I just don't see myself programming in a language where I have to rewrite my own data structures or network code or postgres integration, it's way too much work for way too little gain.

- Tooling. Just look at Java and Go (also Python and JS, albeit to a lesser extent). It's a massive, massive productivity gain to have modern, effective tooling that supports modern workflows.

- Language features. I'm partial to the ML family, but I'm not a radical in this respect, I'll program in almost anything as long as it's sufficiently expressive and doesn't have insane semantics.

A few _very wild_ ideas:

- A configurable type system. I'm sold that stronger and more articulate type systems are the future, but sometimes, especially in smaller projects, it's incredibly annoying to have to prove to the compiler that the code you wrote is actually allowed. There's an inherent expressivity vs. correctness tradeoff that it would be interesting to have "different settings" for.

- A dependency system based on functional semantics rather than names. Imagine to reduce each function to a canonical representation (for example: its De Brujin encoding). Now you can design a dependency system where you can import a function based on its representation rather than its name.

- First-class algebras. Imagine being able to program user-defined structured sets. Strings as monoids, Vec3 as vector spaces, calendar as affine spaces, etc.

Standard ML, but unfrozen and most of the "successorML" proposals integrated into the standard. And it has somehow sprung a large healthy library ecosystem. And the MLton toolchain has gained a REPL.

Typescript without the CJS/ESM/tooling BS. Plus a JIT compiler for performance.

Since I'm not doing lowlevel stuff, for me it would be a statically typed language that has a typesystem so powerful that it never gets in my way and lets me express all constraints in types that I need for my domain (so it must be a value-dependent typesystem or similiar). In addition, the syntax must be terse so that it's easy to define (business) datatypes and mappings easily, so that someone can come in and read those definitions quickly and understand the domain.

And then one feature that I like which few languages support are some kind of contexts. Scala does this really well for example, but even in Scala it could be improved.

What I mean is that code that looks the same can mean different things in different contexts. The typesystem then ensures that it cannot be used wrongly though.

An example would be how "5 ± 3" can mean different things depending on the context, such as "1 or 8" or "mean of 5 with variance of 3" (in statistics).

Without such a feature it's hard to translate thoughts into code as easy in certain domains.

Rust with lisp syntax.

Like what this macro does https://github.com/JunSuzukiJapan/macro-lisp

Wait maybe what I want already exists

Syntax like F# but with the ability to get performance like C++. Linear types seem to offer some hope of being able to have manual / non GC memory management in a functional programming language but I haven't really seen this done in a mature functional language.

To really get good performance you probably need the ability to drop down and write more procedural style code in hot code paths and expose it with a functional interface. The details of what exactly that would look like in a way that integrated nicely would be important. I'd also want to be able to easily move code to the GPU or incrementally vectorize it.

I'd also like to see the one language / runtime support everything from C++ constexpr style compile time programming through native compilation, JIT runtime and an interpreted mode for scripting with it being easy to interoperate between levels and reuse the same code across contexts.

A good ecosystem of tools and libraries with a sane package manager and build system would also be important. F# is decent there but could still use improvement.

I'd also like to see less impedance mismatch between serialization and runtime data structures and with database / relational data. Hoon is pretty interesting in how there is no real distinction between runtime and serialized data in many contexts but its harder to see how to do something like that and meet the other goals above.

Much of the above is driven by the needs of games and VR. I'm interested to see what comes out of Simon Peyton Jones working at Epic as it seems it may lead to something along these lines.

* Strongly, statically typed.

* Good package management.

* Good, easy to reason about build system.

* Popular enough to find jobs with it.

Probably a lot more, but I don't really remember my annoyances unless they're in front of me.

I know this is not pertinent to your question, but i would like to see DLang gain more traction.

I want to write a program that has no mention of concurrency and runs efficiently on clusters anyway. So no threads, fibres, processes, actors, atomic, mutex, channels, queues, coroutines. Not in the language nor in a library.

Push the concurrency and distribution machinery into the language runtime. Developer can neither see nor influence it. Program just runs faster when put on more parallel hardware.

The price appears to be dropping mutation, severely limiting I/O and coming up with a domain independent scheduler for the runtime. So it's expensive but not impossible.

TypeScript without the BC shit (and a native JIT compiler). Basically I wish for a TypeScript that’s maintained like Swift where the primary goal of the latest version of the language is for it to be the best possible language ever.

Aside from what's mentioned already: Longevity. Nothing is more frustrating than being forced to go through already working code just because some version update changed the syntax/semantic.

A universally perfect language can't exist.

There are general purpose languages (say, java, go, rust, ts, and c -- one is better than another for specific tasks), and then there are HDLs, DSLs, constraint and SAT solvers, and many more I don't even know about.

TypeScript, but the only supported module system is ESM (including extension being required like it is in the browser), there is no interface and enum (types and type unions are used instead), there are nameof and typeof operators in the language and there is syntax for getting a runtime value representing a type (for example string union into a string array) or even straight up option/syntax to selectively (up until absolutely) enforce type shapes at runtime.

A haskell-like proof language (dependent types?) with lisp syntax.

To me what matters the most isn't the language but the ecosystem:

- versatility: create desktop apps, mobile apps, websites, CLI

- quality of IDE / tooling

- lots of libraries to deal with all sort of corner problems

- lots of knowledge I can google

- if used professionally: lots of talents available

For the language itself, I only really care about one thing: statically typed, just because it eliminates all sort of silly bugs and makes refactoring and navigating the code so much easier. But I am not dealing with hard computer science problems.

But the most important thing is muscle memory: not having to even think of how to solve something, just do it. We can probably adapt to any major language, but you aren't productive until you develop muscle memory. That's why I am not looking to switch to any shiny new thing unless I have a really compelling reason to do so.

Strongly typed Elixir would be it. Even better if it can be gradually typed like Typescript.

Jose announced that they are working on it but I can’t wait :p

// comments would be my perfect language, write good documentation And leave the coding mostly over to CoPilot, or another AI. Although one needs to understand coding, we should work at a higher level. If you cannot write a good CoPilot prompt, i wouldn't accept you as colleague, if you cannot describe code your unable to properly write your own thoughts, makes you a team disaster. The language itself thus becomes less relevant these days, and the years to come.

Some middle way between F#/Kotlin and Rust. Sum types, generics etc are completely non-negotiable. Something where I can use a GC for 90% and build regions of high perf or low level when needed. I want to say “in this region I want zero allocations” and the compiler will warn if an iterator or closure or something ergonomic-but-expensive allocates in that region. This is where CLR/Jvm lands often fail. I even want to be able to get rid of virtual dispatch and all pointer chasing but only for select regions. In some high level languages I can’t tell whether an abstraction comes at a cost.

In the bulk of the code I want the syntax to be as terse as possible so the business logic is as clear as possible even if it comes at a perf cost. This is where Rust often fails. The logic of something where I don’t care about perf is obscured by token salad for Box’es and similar.