Assume mainstream adoption as used by around 7% of all github projects
Personally, I’d like to see Nim get that growth.
I actually bought the second edition of Mastering Nim paperback the other day! Should be arriving tomorrow, hopefully.
I had fun dogfooding my interview problem in it, I feel like it’s basically step forward as far as modern syntaxes go.
I’m testing for a development project for degree
Malbolge
R
I know is not considered a “proper” programming language by some, but I’ve been working with it for years for scientific data analysis and I love it
Uiua!
⇌[⍥⊃+⊙∘10 1 0]Please no
formal English
Currently out of stock, but what about
use English; use strict;You monster
{-# LANGUAGE OverloadedStrings #-} import qualified Data.Text as T (Text) correctAnswer :: T.Text correctAnswer = "Haskell"Came here for Zig too. I never programmed anything in it other than hello world stuff. I think the world is waiting for the 1.0 release with complete tooling and package manager and a solid foundation that won’t change too soon. I watched talks from Andrew and what this guy and his team is doing is amazing. It’s a small team.
Zig is what I thought Rust would be like when I first heard of Rust. I’d love to try Zig for some hobby things but can’t get it running on OpenBSD (yet!).
codsu
hi
Kotlin! I love that dataclasses and extension methods are a first class citizen.
Rosie Pattern Language, which is an alternative to regular expressions.
Edit: Here is a presentation by the creator
Tanks for this, first time I learn about Rosie, seems promising.
An alternative to regex sounds interesting, too bad their site lacks proper examples and, more importantly, side by side examples of equivalent regex, that’s the best way to sell such an idea.
Futhark: a functional language that can be compiled to run in parallel on cpu or gpu. (No need to write cuda directly) https://futhark-lang.org
I would like to see Ada grow. Its clean syntax, rich expressive capabilities, and early error detection by the compiler due to strict typing create a very pleasant experience during development. This year, the language got a new standard. Recently, a package manager and a community index were created. There’s an extension/LSP for vscode, etc. Along with great educational materials on learn.adacore.com, it’s easy to pick up and start using this language.
PS I created a community on p.d two days ago: https://programming.dev/c/ada
Hi there! Looks like you linked to a Lemmy community using a URL instead of its name, which doesn’t work well for people on different instances. Try fixing it like this: [email protected]
I’m new to Lemmy. Appreciate the heads-up, thank you! 👍
Rust! Memory leak free code would make our world a better place!
Rust doesn’t guarantee the lack of memory leaks anymore then java/C++ does, so sadly not sure if it would help here. :)
We can go further, I think it’s impossible to prevent memory leaks in a general purpose language
Not without a super fancy type system that has to be still found. I think the key issue is cyclic data-structures (e.g. doubly-linked list). The language somehow needs to have strong/weak pointers and automatically determining them is a very complex research question…
Help me understand your point of view. How does Rust not prevent memory leaks?
There’s built in functions to leak memory that are perfectly safe. You can also do one really trivially by making a reference count cycle. https://doc.rust-lang.org/book/ch15-06-reference-cycles.html
Rust only prevents memory unsafety - and memory leaks are perfectly safe. It’s use after frees, double frees, etc. It prevents.
You are absolutely correct that rusts safety features don’t extend to memory leaks, but it’s still better than most garbage collected languages unless you abuse Rc or something, and it does give you quite fine-grained controll over lifetimes, copying and allocations on the heap which in practice means that rust is fairly good about memory leakages compared to most languages.
Reference counting is a GC though ?
It’s a bad one sure and will leak memory in cases of a cycle which most tracing GC are able to do.
It’s main advantage is that there are no GC pauses.
I think you know what I mean when I contrast Rust with GC’d languages, we can call it opt-in garbage collection if we’re being pedantic.
How would rust fare any better then a tracing GC? Realistically I’d expect them to use more memory, and also have worse determinism in memory management - but I fail to really see a case where rust would prevent memory leaks and GC languages wouldn’t.
If you just Rc everything (which I’d count as “abusing Rc”) Rust is significantly worse than a language with a good GC. The good thing about Rust is that it forces you to aknowledge and consider the lifetimes of objects. By default things are allocated on the stack, but if you make something global or dynamically handled (e.g. through Rc) you have to do so explicitly. In Rust the compiler has greater compile time information about when things can be freed which means that you need less runtime overhead to check things and if you want to minimize the amount of potentially long-lived objects you can more easily see how long objects might live by reading the code as well as get help by the compiler to determine if a lifetime-based refactoring is sound or not.
And here you’re only talking about a subset of memory leaks, by inaccessible memory. You can also leak memory by pushing new elements in a channel while never reading them for example.
At this point, I think it’s almost mainstream, and it’s still growing fast (and it’s getting better, rust-analyzer is really awesome these days, I was there at the beginning, no comparison to today…))
I may be biased, but I think it’ll be the next big main language probably leaving other very popular ones behind it in the coming decade (Entry barrier and ease of use got much better over the last couple years, and the future sounds exciting with stuff like this)
I’m obsessed with an extremely little known language called Grain. It’s not quite ready for production but it has an insanely intuitive functional syntax that I want to use noww.
Interesting!
I see OCaml with rust syntax, for the web, which checks out the project goal of bringing functional patterns to everyday programmers.One of the most exciting things about Grain is that it compiles to WebAssembly.
That’s a cool feature.
What is the particularity that you talked about?
In my point of view it looks like JS/TS with arrow functions. 😁it looks like JS/TS with arrow functions.
JS/TS already has arrow functions.
Could you give some examples of what you like so much?
