Val, a new programing language inspired by Swift and Rust | Hacker News Reader

Val, a new programing language inspired by Swift and Rust

29 pointspjmlp19 comments

Dave Abrahams and Dimitri Racordon from Swift and C++ fame, announced during their quite interesting keynote for language geeks at C++Now 2022, a new programming language based on a mix of Swift and Rust ideas, with main focus on being value based and generics

The somehow lenghty keynote (3h), that introduces the background ideas leading up to the language, and the language itself,

"A Future of Value Semantics and Generic Programming"

https://www.youtube.com/watch?v=4Ri8bly-dJs

https://www.youtube.com/watch?v=GsxYnEAZoNI&

If you want to skip it and go straight to the source, it is located at,

https://github.com/val-lang/val

View on HN

So many new programming languages that there is a shortage of names ;-)

When I saw the title I thought it was another post for Vale, but no, it's Val!

* Yesterday post on Vale PL: https://news.ycombinator.com/item?id=31786487

Also, Vala: https://wiki.gnome.org/Projects/Vala

Vala is a really good language, such a shame that barely anybody uses (or maintains) it nowadays..

Vale lead here, there's something lovely about the V and L sounds, it's worth the crowding ;) Very cool language!

Not to be confused with VAL ("Variable Assembly Language), VAL II and VAL 3, programming languages for industrial robots. VAL was developed at Standford in 1973. The others are referred to as being "second gen" and "third gen" robotics languages. They are still in use at various companies.

<https://en.wikipedia.org/wiki/Variable_Assembly_Language>

<https://blog.robotiq.com/the-history-of-robot-programming-la...>

Or the other VAL: “Value-oriented Algorithmic Language” (https://web.archive.org/web/20070920003407/http://hopl.murdo...), which had some interesting influence on parallel and functional languages.

Anyone knows if this is some kind of proof-of-concept language ? Or is there any plan on getting this thing supported in the long run ?

I've always loved dave abrahams contributions on swift forums, and with the recent departure of chris lattner from the swift core team, i start to wonder : is this a first attempt at forking swift ?

EDIT : in case others were wondering, i've just looked at the code and it's obviously just barely getting started. Probably just a POC at this point.

I'm also curious if they have any plans on memory safety. If it's based on Swift and Rust, perhaps they'll do RC?

Memory safety is guaranteed in the safe subset of the language, and we plan to use a naming convention to mark unsafe constructs, like in Swift. One notable difference: pointers are not unsafe; only their dereference operation is.

Definitely worth watching. I also enjoy Dave's Evolution discussions. Even if I don't agree with his take, his thought process and obvious depth of experience is always inspiring. His style of engagement with other participants also makes for a much more constructive thread than many that take place there.

At this stage it is definitely a research language. We're very aware that new languages come along every week and die in obscurity, and the lift to make one successful is huge. That said, I have to admit it's very hard for us to keep from getting excited about taking it all the way to production. Stay tuned.

It's not at all an attempt to fork Swift, although we are taking a LOT from Swift's design, which we like a lot. We'd be very happy if Swift (or Rust, or C++, …) stole the essential ideas and incorporated them.

> “Immutable variables”… (from the GitHub link)

This is something I will never understand. Why is this not a constant (e.g. “Const”) instead? is there a difference, and how should someone new to the language understand how to use one over the other ?

The traditional distinction is that a constant has the same value each time an expression referencing the constant is evaluated (hence a compiler for example can apply constant propagation), whereas the value of a variable referenced in an expression may be different each time the expression is evaluated. The most common example is a local variable, which, even if immutable, will often have a different value for each invocation of the containing function. This is most obvious for function parameters.

With constants, you could replace each occurrence of the constant with its actual value in the program code, without changing the program semantics. With variables you generally cannot do that, because the value will vary at runtime.

Constants can be in ROM, variables need to be in RAM.

They weren't asking about the difference between constants and variables, they were asking about the github link, which talks about using two different variable declarations, one of which can make a variable into a constant while the constant is in scope.

I don’t think so. The example on the GitHub page is:

    var p1 = ...
    let p2 = p1

Where p1 is a mutable variable and p2 is an immutable variable. The GP asks why it isn’t called a constant instead of an immutable variable, which is what I explained.

There's no difference that I'm aware of in Swift. There is in Rust, where a const is a compile-time value but an immutable variable is a value that can be defined anytime and then its immutability is enforced by the compiler.

We've been using the word "binding" in our more formal work (see the specification repo, which is more up-to-date than the README), and having clarified that for ourselves, we will probably stop talking about "immutable variables." A constant is declared with "let" and a non-constant is declared with "var", like in Swift. HTH

macOS only, written in Swift. so pretty useless to everyone else

It should work fine on other platforms supported by Swift (Windows, Linux, …) but hasn't been tested there. And yes, pretty useless to everyone at this stage; it's a work in progress.

Reply on news.ycombinator.com