Drop #316 (2023-08-14): Watch Your Language!
Discover more from hrbrmstr's Daily Drop
Drop #316 (2023-08-14): Watch Your Language!
Hylo; Wing; Wipeout!
Today we take a look at two up-and-coming programming languages that are getting just enough buzz to force me to draw y'all's attention to it. If you'd rather just skip to the third section for a bit of fun, I will take no offense.
TL;DR
This is an AI-generated summary of today's Drop.
I was so impressed with Anthropic's Claude output that I went back to it today with the following prompt: “i need a short, 3 bullet-list summary of the sections in the attached markdown document with the primary resource url clearly linked in each bullet.”. The output did not require editing at all.
Hylo is a new systems programming language that combines mutable value semantics and generic programming to allow for efficient, reusable code. It aims to provide the performance of Rust with the expressiveness of Swift.
Wing is a new cloud-oriented programming language that lets you write both your application code and infrastructure in one language. It aims to simplify cloud development and be friendly to AI assistants.
A fan has ported the classic 90s PlayStation game Wipeout to be playable in web browsers by recompiling leaked source code.
Hylo
Hylo (GH) was created to address the need for a programming language that leverages “mutable value semantics” for the purpose of writing efficient, generic code in a systems programming context. For those just interested in the core semantics, you can skip my blathering and take a language tour of Hylo.
Sigh. All these new languages with their fancy new terms.
“Mutable value semantics” is a programming discipline that upholds the independence of values to support local reasoning. Unlike pure functional programming, mutable value semantics allows part-wise in-place mutation, thereby eliminating the memory traffic usually associated with functional updates of immutable data. This approach enables developers to write code that is both expressive and efficient. Imagine you have a toy train with detachable cars. You can change the order of the cars or add and remove cars to create a different train. This is like mutable value semantics because you can modify the train without needing a completely new one.
“Generic [programming]” is a style of computer programming in which algorithms are written in terms of data types to-be-specified-later that are then instantiated when needed for specific types provided as parameters. This approach reduces duplicate code and allows for the creation of common functions or types that differ only in the set of types on which they operate when used.
“Systems programming” involves the development of software and software platforms that provide services to other software, are performance constrained, or both (e.g., operating systems, computational science applications, game engines, industrial automation, and software as a service applications). Systems programming requires a great degree of hardware awareness and aims to achieve efficient use of available resources. Go, Rust, and even C++ fit into this category, to give you an idea of where Hylo's head is at.
In the Hylo team's own words, Hylo is:
Fast by definition: Hylo is compiled ahead-of-time to machine code and relies on its type system to support in-place mutation and avoid unnecessary memory allocations. Hylo avoids hidden costs such as implicit copies and therefore avoids heavy dependence on an optimizer for basic performance.
Safe by default: Hylo’s foundation of mutable value semantics ensures that ordinary code is memory safe, typesafe, and data-race-free. By explicit, auditable opt-in, programmers can use unsafe constructs for performance where necessary, and can build safe constructs using unsafe ones.
Simple: Hylo borrows heavily from Swift which has demonstrated a user-friendly approach to generic programming and deep support for value semantics. Hylo’s programming model strengthens and extends this support, while de-emphasizing reference semantics and avoiding the complexities that result from trying to make it statically safe (e.g., memory regions, lifetime annotations, etc.).
Ignoring the “Swift” bit, this sounds alot like Rust, so why the heck do we need yet-another language like Rust?
By default, copies in Hylo are explicit. Languages that implicitly copy most values, such as C++, Swift, and R, often do so at the cost of performance. Avoiding implicit copies can also lead to increased code size, complexity, and slower development. However, Hylo requires fewer copies than other languages, making explicit copies in code more salient and less “noisy.” For code where implicit copying is appropriate, Hylo offers a scoped `@implicitcopy“ directive.
In Hylo, distinct bindings and distinct objects have independent values. Languages that allow two accessible names to bind to the same mutable object, such as JavaScript, Python, Ruby, Lua, and parts of C++ and Swift, can be prone to hidden interactions, race conditions, and can scale up into systems that are difficult to document, test, or understand. Hylo ensures that access to a mutable value is through exactly one binding at any given time. In C++ this might look like:
// Create a vector representing a list of numbers
std::vector<int> numbers = {1, 2, 3};
// Create another reference (accessible name) to the same vector
std::vector<int>& anotherNumbers = numbers;
// Modify the first element of the numbers vector
// through the 'anotherNumbers' reference
anotherNumbers[0] = 42;You can't do operations like that in Hylo, but Rust also makes it super hard to do that too.
In fact, the best way I can likely leave you with an explanation of “why Hylo?” is that it seems to be what would have been the byproduct of Rust and Swift having an offspring. I truly like, and use, both of those programming languages, but Rust has many “hard edges” that could definitely use some sanding (I've mentioned, before, that some Rust code is indistinguishable from hieroglyphics) and Swift's expressiveness is great but its evolution into something beyond writing iOS apps is far too slow. In fact, I might argue that Hylo is the “Swiftification” of Rust (Hylo is also written in Swift).
It's not ready for prime time, but I'd keep an eye on this. The language's creator — Dimi Racordon is extremely talented and is heck bent on furthering the modern efforts to make programming languages more expressive, safe, and efficient.
Wing
Wing is a “cloud-oriented” programming language. Most programming languages we used were created by folks or teams who worked under the operational mental model that computers are individual entities. The folks behind Wing envision the cloud as the computer. This is a fairly major, fundamental perspective shift, and in many ways sets Wing apart from the vast cadre of existing programming languages. Y'all had to put up with some major blathering in section one, so let's just get down to business:
Wing:
combines infrastructure and runtime code into a single language. This allows developers to remain in their creative zone, delivering better software faster and more securely.
lets developers run their cloud applications in their local environment. This minimizes context switching and provides immediate feedback, making the development process smoother.
supports any cloud service and can compile to multiple cloud providers and provisioning engines. This gives developers full control over how their infrastructure is configured and deployed.
has syntax that is inspired by modern application development languages like TypeScript, JavaScript, Swift, and more. It's statically-typed, simple, and comes with A++ IDE tooling.
is meant to be used by us humans and our AI co-pilots. Yes, Wing is being developed with the idea that we will be increasingly relying on our LLM/GPT overlords to help reduce cognitive load and speed up how we do things.
This is Wing's most basic example, uploading data to a service-agnostic “bucket”:
bring cloud;
let bucket = new cloud.Bucket();
new cloud.Function(inflight () => {
bucket.put("hello.txt", "world!");
});Wing's compiler handles all of the IAM policies and other cloud-specific details (I mean, you do have to give it access to your cloud setups for it to grok that). You'd need to write ~120 likes of Terraform code (the devs do seem to like Terraform very much).
A slightly more interesting and IRL example can be found in their URL shortener Wing code.
Wing also seems fairly tightly coupled to the JavaScript ecosystem (you install it via npm) as it is to Teraform, but it's agnostics to both language and orchestrator. It's also not fully open source.
While there is much to like about Wing — especially how it may enable AI assistants to whittle us down to a 3- or 4-day work week (a girl can dream) — my Spidey-sense keeps preventing me from delving into it in any significant way. I'm not sure if that's due to the icky licensing of the core “product”, some of the hand-waviness around what it does right now, or that it has attracted the attention of what remains of the venture capital space in 2023.
Still, it's good to be aware of up-and-coming offerings, especially those that are focusing on how to make it easier for AI to use new tools in a safe and effective way.
Wipeout!
I've given you one thing you really can't use right now, and another thing you likely won't use. So, I feel compelled to include something that at least has a chance of you using it, possibly even right after reading this section!
A fan has ported the classic PlayStation game Wipeout, so it can be played in a web browser. Dominic Szablewski recompiled the leaked source code from 2022 to make it web compatible (WASM FTW!!).
It turns out that the original source code was of shocklingly low quality, as it contained piled on versions from different ports.
Old timers like me will remember when Wipeout was first released back in 1995 for the original PlayStation (and DOS) and was a big hit. It featured in several remaster collections like Wipeout Omega Collection from 2017.
Dominic’s port is still a work in progress, with bugs to fix and more features to add.
Read along with his continued porting effort over at the dev blog
FIN
Year progress: ▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░ 62%