You are almost 3500 commits in to this project already, with no other contributors? The dedication to this is incredible. It sounds super compelling and I wish you luck!
I hope you get more recognition to encourage you to continue. These new languages are so important in pushing forward our tooling and our understanding of workable abstractions as an industry. I am only recently getting into functional programming and it has already fundamentally changed a lot of my perspective on OO, composition vs inheritance, immutability, pure functions, etc.
Have you considered trying to make this a little more accessible (a bit of a focus on the marketing side?) I would really like to digest the main benefits of your language more easily.
One example is that when skimming your readme, the first thing my eye is drawn to is the bulleted section which talks about other limited memory management solutions. But if I didn’t read the small text before it that says “neut doesn’t use these” I do not understand the compelling feature of the language to dive in further.
Have you followed Zig Lang? Andrew Kelly is doing something similar (in so far as he’s building a new language focused on memory management) and even though I don’t use it, I see the value in this work and support him on Patreon.
I would be happy to help you with reviewing the copy on the readme from the perspective of someone who is technical but not super knowledgeable in this domain to help you summarize the key concepts and advantages up front. Reach out to me with the email in my profile if you would like to discuss!
Personally, I found the initial intro surprisingly easy to read and digest. I got double surprised when I noticed this is written in Haskell (IIUC) - for a thing created by a Haskell guy, this is incredibly readable and easy to digest. Typically you'd get swamped by monads, morphisms, equations and deep CompSci references. I can only say thank you for really putting an effort into making the readme approachable. I know how much work a reader-oriented readme takes. And another huge congrats for releasing and publishing on HN! This looks super interesting.
I'd be interested to hear what about it made it easy to read and digest. For example, it starts with
> The (with identity.bind (...)) is the same as the do-notation in Haskell or other languages, specialized to the identity monad.
The next section is called "Types as Exponentializers". The section after that explains
> That is, a lambda-abstraction is translated into a tuple consists of (0) the type of its closed chain, (1) its closed chain, and (2) a pointer to an appropriately-arranged closed function
As a Haskell fan this sounds like perfectly normal Haskell-speak. Is there something about it that makes is more digestible to you than the average Haskell-speak?
There are various reading/learning styles. For a "understand each step before moving to the next" style, local incomprehensibility has strong implications for global. But for a "didn't understand that bit, so skip ahead" style, what matters is recoverability - robustness to localized incomprehension. How "lost" you become when you don't understand some bit.
Here, if you don't understand identity.bind, or even do-notation, you can read on without losing much. Not understanding the section title, is not an obstacle to understanding the section. And so on.
The intro has nice non-local clarity. The dialog structure; having summaries.
I'd not stereotype a "Haskell writing style", but I certainly encounter writing elsewhere which seems to reflect a mindset of "since you've reached this paragraph N, you obviously fully understand, remember, and appreciate the implications of, everything that has been said earlier, so we can happily take this next step without any distracting redundancy, context, motivation, or other annotation". Which... needs to be approached in a particular way to avoid degrading nongracefully.
I also appreciated the intro's "here's how I suggest approaching learning the language".
Heh, sorry, you're totally right, parts are definitively 100% Haskell-speak for sure (and I totally jumped over them with 0 understanding); what I really meant and failed to clearly convey, is that there are the other parts, including esp. the intro paragraphs, that (at least) to me personally were very approachable. Looking over again:
"Neut is (...) memory management" - first para ok, incl. the bullet list - specifically what original commenter complained about, for me was no problemo
"Theoretically (...) terms of the type" - 100% Haskell-speak, no slightest idea what it means, skipped; but relatively short optically, and author still has some credit after first para, so I still take a look further
"Practically, this means (...)" - cool, I can understand again! I think that's where I got hooked: now I know the author sprinkles their Haskell-speak because of an unstoppable inner need to be precise and probably also so that the tribe doesn't expell them, but they also seem to have this amazing spark of humanity and empathy towards common programmer folk, so that if I skip over the mysterious ivory-tower spells, I will find more nuggets of commoner-speak for me. Knowing a bit more about writing, I believe they additionally probably consciously put a lot of effort to write in an approachable way. Which is a surprisingly tough skill. This is a mix I honestly bow to. I can try and list more paras that were cool for me if you'd specifically like me to.
That is a great summary from an outsider perspective, I hope when I post my in-progress language release (on July 1), someone like you is around to give such an honest read.
P.S. Also, I only put that July 1 date as further personal reinforcement that I am going to meet my self imposed release deadline. Gotta keep the pressure on or I’m sure I’ll hold it as a private project forever.
Thank you for kind words! Yes, I think 3500 commits are enough to make things that might need further explanation too obvious to the author. A feedback from someone like you is really helpful. Please feel free to open an issue (or send me an email if you'd like).
I know Zig language (I've seen it before in an article that compares the binary sizes of hello world of various languages IIRC), though I don't know it in detail. Sounds interesting, I'll take a look at it.
We've entered an era where new languages are almost never used. The Go and Rust story are exceptions. This is the long thin tail of new language adoption.
> We've entered an era where new languages are almost never used
I disagree. The same was said when perl dominated before Ruby and Python came along. And Pascal, C and C++ before that. Nowadays Nim, Crystal, Rust, Go, F#, D, Zig, JavaScript, Haskell, and more are all viable options for application development.
We have more viable programming languages than ever.
I live in a moderately large urban area in france (~800k inhabitants) and for your list ("Nim, Crystal, Rust, Go, F#, D, Zig, JavaScript, Haskell") I've never seen any local job ad for any of those except JS and Go, and only saw a bit of Haskell at the university.
From a quick glance over a few dozen pages of job ads, it's mostly Java & PHP, with a bit of JS, Python and C# here and there and some C/C++ in embedded. Saw 2 node.js ads, as well as a COBOL and a Kotlin too.
So, yes, maybe they are viable. But.. used ? they're blimps in the radar next to the big ones.
Sadly just because a language has a quality implementation and lots of libraries available and so is suitable for application development from an engineering point of view doesn't mean that PHBs are going to allow it to happen at the workplace, for various business reasons.
Languages like this are usually not meant for mainstream adoption.
It's more of a research language useful as a vehicle for exploring new concepts and approaches. Target audience is probably other programming language researchers.
> Programming languages researchers are like fashion designers and "research languages" like Haskell and Idris are like runway looks. Nobody expects people to go around snakes on their bodies. They're pushing the boundaries of art and science and showing what's possible.
And just like in fashion, the runway looks eventually change what people are wearing. Rust’s memory management would never exist in its current form if Cyclone hadn’t already shown it was possible.
Interesting analogy, but people are using Haskell, Prolog, etc. in production... if I were to stick to the comparison, I'd suggest that projects like Lighttable are more akin to the runway outfit.
Hm. Interesting, but I’d consider the languages with actual production use to be the “ready to wear” lineups. Where as things like this might be the haute couture runway looks.
That'd probably be your languages with large/cohesive libraries (I'm thinking ready to wear as in large retail).
Production-history without expansive libs is probably bespoke and half a complete library (eg rust/go, having half of what you want, and missing the other half) is boutique :-)
Sure. But rust was not possible without all the research and little prototype languages. I think it’s good that many people are trying many things (as long as they clearly report their findings).
People have been saying this for many decades, and they've been wrong ever since. (I ran across, at one point, someone mentioning in the 1960s or so that they were loathe to design a new programming language because how could it possibly compete with existing languages like assembler, FORTRAN, or Lisp?) There are constantly new niches opening up and new areas of growth that a programming language can grow up within. It's a big world out there. There's probably a language stumbling backwards into success right now in China neither you nor I have heard of.
As so often, Alan Perlis said it best: "In a 5 year period we get one superb programming language. Only we can't control when the 5 year period will begin."
I'd say this claim falls victim to a survivorship bias viewpoint. I suppose new languages are now used with more or less the same uptake as in any earlier "era" of software. (I.e. tons of "old" languages, which were new when published, also died with basically no users. Conversely, there's also Nim, Zig, TypeScript, Crystal, .......... just from the top of my head. Totally making their rounds and worth watching, and with people trying to use them.)
I hope you get more recognition to encourage you to continue. These new languages are so important in pushing forward our tooling and our understanding of workable abstractions as an industry. I am only recently getting into functional programming and it has already fundamentally changed a lot of my perspective on OO, composition vs inheritance, immutability, pure functions, etc.
Have you considered trying to make this a little more accessible (a bit of a focus on the marketing side?) I would really like to digest the main benefits of your language more easily. One example is that when skimming your readme, the first thing my eye is drawn to is the bulleted section which talks about other limited memory management solutions. But if I didn’t read the small text before it that says “neut doesn’t use these” I do not understand the compelling feature of the language to dive in further.
Have you followed Zig Lang? Andrew Kelly is doing something similar (in so far as he’s building a new language focused on memory management) and even though I don’t use it, I see the value in this work and support him on Patreon.
I would be happy to help you with reviewing the copy on the readme from the perspective of someone who is technical but not super knowledgeable in this domain to help you summarize the key concepts and advantages up front. Reach out to me with the email in my profile if you would like to discuss!