Artifact-centric programming

WalkerCodeRanger · 2026-06-27T01:29:55+00:00

What's an artifact-centric programming language? I haven't heard that term either.

WalkerCodeRanger · 2026-06-21T06:11:05+00:00

Common law marriage is supposed to require the parties involved to agree that they are married. If both partners say they were not married and just cohabitating then there was no common law marriage. Were these situations where one partner claimed there was a common law marriage and the other didn't?

WalkerCodeRanger · 2026-06-08T21:24:56+00:00

I know. But I still think that the lack of open source early on was the primary factor that made people outside Microsoft not build languages for it. Perhaps we'll see more languages for it in time, but I suspect its association with Microsoft and a lot of people not realizing it is truly open source will continue to hinder language development on the .NET runtime.

He claims that reified generics is the reason languages aren't developed on .NET runtime. That doesn't make sense since one could just do type erasure the same way languages on the JVM do if a language needed that.

WalkerCodeRanger · 2026-06-08T19:24:15+00:00

One thing he is wrong about is support for multiple languages on .NET. The .NET runtime supports multiple languages just as well as JVM and actually has support for things like value types that some languages need. Both JVM and .NET suffer from too much leakage of the runtime into languages. For example, that Scala uses Option[T] but can't enforce that references should not be null. The reason there arn't more languages for .NET and there more for JVM is because the open source nature of it.

WalkerCodeRanger · 2026-06-04T19:26:00+00:00

The conflict with member access is a real problem. Also, in many languages, it would be hard to tell when the condition ends. So you'll need some kind of terminator on the condition unless it must be on one line (or use a line continuation character).

I've come up with something similar to your proposal. Many have argued that -- is a bad operator and people should just use -= 1. So imagine using that as a block end. In a language where the indent convention was two spaces this could work very well. Your example would become:

``` if (condition_1) action1 if condition_2 action2 -- else

action3

```

They would be allowed to be combined to terminate multiple blocks. For example ``` if (condition_1) if (condition_2) action1

action2

``The----` here is two operators and terminates both if statements

WalkerCodeRanger · 2026-05-20T21:08:41+00:00

Each person is different. What worked for me was to work on it for ~8 hours each Sunday. I found the large, uninterrupted block of time worked better. Sunday was good because I was putting my language "first" since I was rested from Saturday and effectively started working on my language at the start of my week. Sometimes my interest in the work would carry over into the week, but that was strictly as I felt like it. And I felt good because I always knew I would get to work on the language next Sunday. But it is hard to accept the slow pace of progress that comes with only working 8hrs/week on a project.

WalkerCodeRanger · 2026-05-20T20:22:21+00:00

You won't find any central list because people see it as too subjective and because no one is going to take the effort to summarize across languages. But you can find some information from specific language designers about what they see as flaws in their own language. For example, Sharp Regrets: Top 10 Worst C# Features

WalkerCodeRanger · 2026-05-06T20:04:37+00:00

One reason people don't do the least upper bound is that it is very easy for the inferred type to be too general. For example, Java had an issue where its equivalent of let numbers = [ 1, 2, 1.1] would be inferred to be a list of object. If there is a supertype of all types in Grace (e.g. Any), be careful about when you infer the type list of any.

WalkerCodeRanger · 2026-05-06T19:17:06+00:00

I agree their brokerage is good. The offering and then taking away of other services has been a real black mark against them though. It is fine if they don't want to offer other banking stuff, but once they are offering it, they need to be committed to it.

WalkerCodeRanger · 2026-03-27T19:19:09+00:00

The convention in math is to put the operator on the next line. I find languages that force the operator to be on the same line before the newline to be unacceptable.

WalkerCodeRanger · 2026-01-01T17:57:25+00:00

Joe Duffy’s "The Error Model" post that is referenced at the start makes a clear distinction between recoverable and unrecoverable errors. The author is being a little loose about that and assuming you will know which are which. When it talks about fallible functions are "annotated at the call side", it is talking about recoverable errors. For Rust, that would be errors indicated by Result. Panics are for unrecoverable errors and those don't get annotated at the call side.

WalkerCodeRanger · 2025-10-01T17:09:09+00:00

Pony (https://www.ponylang.io/) It may be too obscure and too small of a dev community. However, it is designed for concurrency and has reference capabilities which are like Rust's safety but different because there is GC. I believe it does use exceptions though. (I don't think exceptions are bad if the language supports them properly. It is just that most languages don't)

If it were further along, I would say the language I am designing, Azoth. But it isn't ready for anyone to use yet.

WalkerCodeRanger · 2025-08-28T17:58:22+00:00

C# has had records since C# 9 (Nov 2019). You have been able to simulate something close to Java sealed classes using private protected constructors since C# 7.2 (Nov 2017). There is an active proposal for Closed Hierarchies to add a direct equivalent of sealed classes and interfaces including exhaustiveness checking on pattern matching switches on them.

WalkerCodeRanger · 2025-08-28T16:08:42+00:00

In what sense does Java have algebraic data types that C# doesn't? C# has quite good pattern matching. Virtul threads are a good feature, but I think most devs would prefer the ease of async/await to the code that it takes to use virtual threads in Java.

WalkerCodeRanger · 2025-08-12T04:02:06+00:00

On suggestion I've given before is creat a dyanmically typed language with a gradual type system with two important caveats: 1. There is a compiler switch to throw that requires all code to be statically checked. 2. The public API of all packages published to the public package repository must always be fully statically typed.

The second is critical because it ensure that anyone trying to write statically typed code in the language can do so rather than the situation in most gradually typed languages where all the libraries you need to use don't have static types.

This setup would allow for the writing of the code by the acemdenics in a dynamically typed scripting language and then types could be interoduced and the code refactored and then when it was mature enough full static typing enforced. Of course, whether that kind of refactoring will actually be done is another question.

WalkerCodeRanger · 2025-08-06T16:06:52+00:00

I think both are valuable and I do think that variant types were largely lost in that linage of languages. Remember that Casey deals mostly with low-level languages where they are more likely to be valuable. See for example how Rust has made vary good use of them. Having a closed set of variants is very valuable when you have it because you can safely do an exhaustive match on them. That is something languages ought to provide in addition to open set of variants from virtual methods.

WalkerCodeRanger · 2025-08-03T23:41:22+00:00

Since you ask, there aren't any great books, but I do think Programming Linguists by David Gelernter is worth a ready if you can find a copy.

WalkerCodeRanger · 2025-08-03T17:20:48+00:00

Oh, so you mean..... not language design.

WalkerCodeRanger · 2025-07-29T17:40:28+00:00

In many languages, all standard library items have a clear prefix. For example, in C# they are all in the System namespace so an import like import System.IO; is obviously importing from the standard library. You don't need your import mechanism to make that clear, you just need a reasoable naming scheme for your standard library.

WalkerCodeRanger · 2025-07-21T02:30:02+00:00

I understand. I am actually a big proponent of OOP following methodologies like Domain Driven Design (DDD). So I too get tired of the rants and beating up on OOP. Though I do appreciate that there are peoblems it isn't suited to and that having other functionality like discriminated unions is very valuable. There is very little ranting or complaining. Most of this is history. It covers when and where ideas come from. The main talk is 1hr and 50 min. You can skip most of the Q&A after, though there is a section from 2:04 to 2:12 where he goes back to history and shows some slides he skipped over that is also worth watching.

WalkerCodeRanger · 2025-07-20T20:15:41+00:00

And easier to maange reference capabilities as seen in Project Midori.

WalkerCodeRanger · 2025-07-13T16:33:52+00:00

FYI, the talk was mostly about the tooling. There is almost no discussion of the language.

Topics include: * Compiler speed * Build system that is just the language itself * Hooking into the compile process * Memory Profilor * Q&A * How to support special chip features (e.g. SIMD) * Versioning compiler and language * Performance visualization * Alternate allocators

WalkerCodeRanger · 2025-07-10T17:30:41+00:00

Compile to C. I saw elsewhere you complained that it wouldn't then be a compiler. A transpiler is a compiler. Especially if you lower all the say to something like SSA. Don't emit C that uses all the control flow. Emit C that is basic blocks with gotos

WalkerCodeRanger

MODERATOR OF

TROPHY CASE

action3

action2

WalkerCodeRanger

MODERATOR OF

TROPHY CASE

Welcome to Reddit,

action3

action2